test_needimport.ambr

# serializer version: 1
# name: test_import_builder[test_app0]
  dict({
    'current_version': '1.0',
    'versions': dict({
      '1.0': dict({
        'needs': dict({
          'IMPL_01': dict({
            'content': 'Incoming links of this spec: :need_incoming:`IMPL_01`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'IMPL_01',
            'is_import': True,
            'lineno': 4,
            'links': list([
              'OWN_ID_123',
            ]),
            'links_back': list([
              'T_C3893',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'Implementation for specification',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'OWN_ID_123': dict({
            'content': 'Outgoing links of this spec: :need_outgoing:`OWN_ID_123`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'OWN_ID_123',
            'is_import': True,
            'lineno': 4,
            'links': list([
              'R_F4722',
            ]),
            'links_back': list([
              'IMPL_01',
              'T_C3893',
              'filter_IMPL_01',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'Specification of a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'REQ_001': dict({
            'content': '''
              This is an awesome requirement and it includes a nice title,
              a given id, a tag and this text as description.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'REQ_001',
            'is_import': True,
            'lineno': 4,
            'links_back': list([
              'S_503A1',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'example',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'REQ_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'REQ_1',
            'lineno': 47,
            'section_name': 'FILTERED',
            'sections': list([
              'FILTERED',
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'Test requirement 1',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'ROLES_REQ_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'ROLES_REQ_1',
            'is_import': True,
            'lineno': 4,
            'links_back': list([
              'ROLES_REQ_2',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'Sliced Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'ROLES_REQ_2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'ROLES_REQ_2',
            'is_import': True,
            'lineno': 4,
            'links': list([
              'ROLES_REQ_1',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'Butter on Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'R_22EB2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'R_22EB2',
            'is_import': True,
            'lineno': 4,
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'B',
              'filter',
            ]),
            'title': 'Requirement B',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'R_2A9D0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'R_2A9D0',
            'is_import': True,
            'lineno': 4,
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'A',
              'filter',
            ]),
            'title': 'Requirement A',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'R_F4722': dict({
            'content': '''
              This is my **first** requirement!!
              
              .. note:: You can use any rst code inside it :)
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'R_F4722',
            'is_import': True,
            'lineno': 4,
            'links_back': list([
              'OWN_ID_123',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'requirement',
              'test',
              'awesome',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'SPEC_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'SPEC_1',
            'lineno': 50,
            'section_name': 'FILTERED',
            'sections': list([
              'FILTERED',
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'Test specification 1',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'S_01A67': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'S_01A67',
            'is_import': True,
            'lineno': 4,
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'B',
              'filter',
            ]),
            'title': 'Specification B',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'S_503A1': dict({
            'content': '''
              We haven't set an **ID** here, so sphinxcontrib-needs
              will generated one for us.
              
              But we have **set a link** to our first requirement and
              also a *status* is given.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'S_503A1',
            'is_import': True,
            'lineno': 4,
            'links': list([
              'REQ_001',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'done',
            'tags': list([
              'important',
              'example',
            ]),
            'title': 'Spec for a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'S_D70B0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'S_D70B0',
            'is_import': True,
            'lineno': 4,
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'A',
              'filter',
            ]),
            'title': 'Specification A',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'TEST_01': dict({
            'content': 'TEST IMPORT TITLE',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'TEST_01',
            'is_import': True,
            'lineno': 4,
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'title': 'TEST IMPORT DESCRIPTION',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'T_5CCAA': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'T_5CCAA',
            'is_import': True,
            'lineno': 4,
            'parent_needs_back': list([
              'T_C3893',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'awesome',
              'filter',
            ]),
            'title': 'Test 1',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'T_C3893': dict({
            'content': '''
              This test checks :need:`impl_01` for :need:`OWN_ID_123` inside a
              Python 2.7 environment.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'T_C3893',
            'is_import': True,
            'lineno': 4,
            'links': list([
              'IMPL_01',
              'OWN_ID_123',
            ]),
            'parent_need': 'T_5CCAA',
            'parent_needs': list([
              'T_5CCAA',
            ]),
            'section_name': 'TEST DOCUMENT IMPORT',
            'sections': list([
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'implemented',
            'tags': list([
              'test',
              'user_interface',
              'python27',
            ]),
            'title': 'Test for XY',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'collapsed_IMPL_01': dict({
            'content': 'Incoming links of this spec: :need_incoming:`collapsed_IMPL_01`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_IMPL_01',
            'is_import': True,
            'lineno': 16,
            'links': list([
              'collapsed_OWN_ID_123',
            ]),
            'links_back': list([
              'collapsed_T_C3893',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Implementation for specification',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'collapsed_OWN_ID_123': dict({
            'content': 'Outgoing links of this spec: :need_outgoing:`collapsed_OWN_ID_123`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_OWN_ID_123',
            'is_import': True,
            'lineno': 16,
            'links': list([
              'collapsed_R_F4722',
            ]),
            'links_back': list([
              'collapsed_IMPL_01',
              'collapsed_T_C3893',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Specification of a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'collapsed_REQ_001': dict({
            'content': '''
              This is an awesome requirement and it includes a nice title,
              a given id, a tag and this text as description.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_REQ_001',
            'is_import': True,
            'lineno': 16,
            'links_back': list([
              'collapsed_S_503A1',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'example',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'collapsed_ROLES_REQ_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_ROLES_REQ_1',
            'is_import': True,
            'lineno': 16,
            'links_back': list([
              'collapsed_ROLES_REQ_2',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Sliced Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'collapsed_ROLES_REQ_2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_ROLES_REQ_2',
            'is_import': True,
            'lineno': 16,
            'links': list([
              'collapsed_ROLES_REQ_1',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Butter on Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'collapsed_R_22EB2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_R_22EB2',
            'is_import': True,
            'lineno': 16,
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'B',
              'filter',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Requirement B',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'collapsed_R_2A9D0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_R_2A9D0',
            'is_import': True,
            'lineno': 16,
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'A',
              'filter',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Requirement A',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'collapsed_R_F4722': dict({
            'content': '''
              This is my **first** requirement!!
              
              .. note:: You can use any rst code inside it :)
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_R_F4722',
            'is_import': True,
            'lineno': 16,
            'links_back': list([
              'collapsed_OWN_ID_123',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'requirement',
              'test',
              'awesome',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'collapsed_S_01A67': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_S_01A67',
            'is_import': True,
            'lineno': 16,
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'B',
              'filter',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Specification B',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'collapsed_S_503A1': dict({
            'content': '''
              We haven't set an **ID** here, so sphinxcontrib-needs
              will generated one for us.
              
              But we have **set a link** to our first requirement and
              also a *status* is given.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_S_503A1',
            'is_import': True,
            'lineno': 16,
            'links': list([
              'collapsed_REQ_001',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'done',
            'tags': list([
              'important',
              'example',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Spec for a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'collapsed_S_D70B0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_S_D70B0',
            'is_import': True,
            'lineno': 16,
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'A',
              'filter',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Specification A',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'collapsed_TEST_01': dict({
            'content': 'TEST IMPORT TITLE',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_TEST_01',
            'is_import': True,
            'lineno': 16,
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'TEST IMPORT DESCRIPTION',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'collapsed_T_5CCAA': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_T_5CCAA',
            'is_import': True,
            'lineno': 16,
            'parent_needs_back': list([
              'collapsed_T_C3893',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'awesome',
              'filter',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Test 1',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'collapsed_T_C3893': dict({
            'content': '''
              This test checks :need:`impl_01` for :need:`collapsed_OWN_ID_123` inside a
              Python 2.7 environment.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'collapsed_T_C3893',
            'is_import': True,
            'lineno': 16,
            'links': list([
              'collapsed_IMPL_01',
              'collapsed_OWN_ID_123',
            ]),
            'parent_need': 'collapsed_T_5CCAA',
            'parent_needs': list([
              'collapsed_T_5CCAA',
            ]),
            'section_name': 'COLLAPSED',
            'sections': list([
              'COLLAPSED',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'implemented',
            'tags': list([
              'test',
              'user_interface',
              'python27',
              'should',
              'be',
              'collapsed',
            ]),
            'title': 'Test for XY',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'filter_IMPL_01': dict({
            'content': 'Incoming links of this spec: :need_incoming:`filter_IMPL_01`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'filter_IMPL_01',
            'is_import': True,
            'lineno': 29,
            'links': list([
              'OWN_ID_123',
            ]),
            'section_name': 'FILTERED',
            'sections': list([
              'FILTERED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
            ]),
            'title': 'Implementation for specification',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'hidden_IMPL_01': dict({
            'content': 'Incoming links of this spec: :need_incoming:`hidden_IMPL_01`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_IMPL_01',
            'is_import': True,
            'lineno': 9,
            'links': list([
              'hidden_OWN_ID_123',
            ]),
            'links_back': list([
              'hidden_T_C3893',
            ]),
            'parent_need': 'hidden_TEST_01',
            'parent_needs': list([
              'hidden_TEST_01',
            ]),
            'parent_needs_back': list([
              'hidden_OWN_ID_123',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'hidden',
            ]),
            'title': 'Implementation for specification',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'hidden_OWN_ID_123': dict({
            'content': 'Outgoing links of this spec: :need_outgoing:`hidden_OWN_ID_123`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_OWN_ID_123',
            'is_import': True,
            'lineno': 9,
            'links': list([
              'hidden_R_F4722',
            ]),
            'links_back': list([
              'hidden_IMPL_01',
              'hidden_T_C3893',
            ]),
            'parent_need': 'hidden_IMPL_01',
            'parent_needs': list([
              'hidden_IMPL_01',
            ]),
            'parent_needs_back': list([
              'hidden_REQ_001',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'hidden',
            ]),
            'title': 'Specification of a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'hidden_REQ_001': dict({
            'content': '''
              This is an awesome requirement and it includes a nice title,
              a given id, a tag and this text as description.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_REQ_001',
            'is_import': True,
            'lineno': 9,
            'links_back': list([
              'hidden_S_503A1',
            ]),
            'parent_need': 'hidden_OWN_ID_123',
            'parent_needs': list([
              'hidden_OWN_ID_123',
            ]),
            'parent_needs_back': list([
              'hidden_ROLES_REQ_1',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'example',
              'hidden',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'hidden_ROLES_REQ_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_ROLES_REQ_1',
            'is_import': True,
            'lineno': 9,
            'links_back': list([
              'hidden_ROLES_REQ_2',
            ]),
            'parent_need': 'hidden_REQ_001',
            'parent_needs': list([
              'hidden_REQ_001',
            ]),
            'parent_needs_back': list([
              'hidden_ROLES_REQ_2',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'hidden',
            ]),
            'title': 'Sliced Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'hidden_ROLES_REQ_2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_ROLES_REQ_2',
            'is_import': True,
            'lineno': 9,
            'links': list([
              'hidden_ROLES_REQ_1',
            ]),
            'parent_need': 'hidden_ROLES_REQ_1',
            'parent_needs': list([
              'hidden_ROLES_REQ_1',
            ]),
            'parent_needs_back': list([
              'hidden_R_22EB2',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'hidden',
            ]),
            'title': 'Butter on Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'hidden_R_22EB2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_R_22EB2',
            'is_import': True,
            'lineno': 9,
            'parent_need': 'hidden_ROLES_REQ_2',
            'parent_needs': list([
              'hidden_ROLES_REQ_2',
            ]),
            'parent_needs_back': list([
              'hidden_R_2A9D0',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'B',
              'filter',
              'hidden',
            ]),
            'title': 'Requirement B',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'hidden_R_2A9D0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_R_2A9D0',
            'is_import': True,
            'lineno': 9,
            'parent_need': 'hidden_R_22EB2',
            'parent_needs': list([
              'hidden_R_22EB2',
            ]),
            'parent_needs_back': list([
              'hidden_R_F4722',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'A',
              'filter',
              'hidden',
            ]),
            'title': 'Requirement A',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'hidden_R_F4722': dict({
            'content': '''
              This is my **first** requirement!!
              
              .. note:: You can use any rst code inside it :)
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_R_F4722',
            'is_import': True,
            'lineno': 9,
            'links_back': list([
              'hidden_OWN_ID_123',
            ]),
            'parent_need': 'hidden_R_2A9D0',
            'parent_needs': list([
              'hidden_R_2A9D0',
            ]),
            'parent_needs_back': list([
              'hidden_S_01A67',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'requirement',
              'test',
              'awesome',
              'hidden',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'hidden_S_01A67': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_S_01A67',
            'is_import': True,
            'lineno': 9,
            'parent_need': 'hidden_R_F4722',
            'parent_needs': list([
              'hidden_R_F4722',
            ]),
            'parent_needs_back': list([
              'hidden_S_503A1',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'B',
              'filter',
              'hidden',
            ]),
            'title': 'Specification B',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'hidden_S_503A1': dict({
            'content': '''
              We haven't set an **ID** here, so sphinxcontrib-needs
              will generated one for us.
              
              But we have **set a link** to our first requirement and
              also a *status* is given.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_S_503A1',
            'is_import': True,
            'lineno': 9,
            'links': list([
              'hidden_REQ_001',
            ]),
            'parent_need': 'hidden_S_01A67',
            'parent_needs': list([
              'hidden_S_01A67',
            ]),
            'parent_needs_back': list([
              'hidden_S_D70B0',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'done',
            'tags': list([
              'important',
              'example',
              'hidden',
            ]),
            'title': 'Spec for a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'hidden_S_D70B0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_S_D70B0',
            'is_import': True,
            'lineno': 9,
            'parent_need': 'hidden_S_503A1',
            'parent_needs': list([
              'hidden_S_503A1',
            ]),
            'parent_needs_back': list([
              'hidden_T_5CCAA',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'A',
              'filter',
              'hidden',
            ]),
            'title': 'Specification A',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'hidden_TEST_01': dict({
            'content': 'TEST IMPORT TITLE',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_TEST_01',
            'is_import': True,
            'lineno': 9,
            'parent_needs_back': list([
              'hidden_IMPL_01',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'hidden',
            ]),
            'title': 'TEST IMPORT DESCRIPTION',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'hidden_T_5CCAA': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_T_5CCAA',
            'is_import': True,
            'lineno': 9,
            'parent_need': 'hidden_S_D70B0',
            'parent_needs': list([
              'hidden_S_D70B0',
            ]),
            'parent_needs_back': list([
              'hidden_T_C3893',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'awesome',
              'filter',
              'hidden',
            ]),
            'title': 'Test 1',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'hidden_T_C3893': dict({
            'content': '''
              This test checks :need:`impl_01` for :need:`hidden_OWN_ID_123` inside a
              Python 2.7 environment.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'hidden_T_C3893',
            'is_import': True,
            'lineno': 9,
            'links': list([
              'hidden_IMPL_01',
              'hidden_OWN_ID_123',
            ]),
            'parent_need': 'hidden_T_5CCAA',
            'parent_needs': list([
              'hidden_T_5CCAA',
            ]),
            'section_name': 'HIDDEN',
            'sections': list([
              'HIDDEN',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'implemented',
            'tags': list([
              'test',
              'user_interface',
              'python27',
              'hidden',
            ]),
            'title': 'Test for XY',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'ids_ROLES_REQ_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'ids_ROLES_REQ_1',
            'is_import': True,
            'lineno': 34,
            'links_back': list([
              'ids_ROLES_REQ_2',
            ]),
            'section_name': 'FILTERED',
            'sections': list([
              'FILTERED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
            ]),
            'title': 'Sliced Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'ids_ROLES_REQ_2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'ids_ROLES_REQ_2',
            'is_import': True,
            'lineno': 34,
            'links': list([
              'ids_ROLES_REQ_1',
            ]),
            'section_name': 'FILTERED',
            'sections': list([
              'FILTERED',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
            ]),
            'title': 'Butter on Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'small2_TEST_03': dict({
            'content': 'AAA',
            'docname': 'subdoc/filter',
            'external_css': 'external_link',
            'id': 'small2_TEST_03',
            'is_import': True,
            'lineno': 8,
            'section_name': 'Filter',
            'sections': list([
              'Filter',
            ]),
            'status': 'open',
            'title': 'AAA',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'small_TEST_02': dict({
            'content': 'small_TEST_02',
            'docname': 'subdoc/filter',
            'external_css': 'external_link',
            'id': 'small_TEST_02',
            'is_import': True,
            'lineno': 4,
            'section_name': 'Filter',
            'sections': list([
              'Filter',
            ]),
            'status': 'open',
            'tags': list([
              'test_02',
              'test',
            ]),
            'title': 'TEST_02 DESCRIPTION',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'small_abs_path_TEST_02': dict({
            'content': 'small_abs_path_TEST_02',
            'docname': 'subdoc/abs_path_import',
            'external_css': 'external_link',
            'id': 'small_abs_path_TEST_02',
            'is_import': True,
            'lineno': 6,
            'section_name': 'Absolute path import test',
            'sections': list([
              'Absolute path import test',
            ]),
            'status': 'open',
            'tags': list([
              'test_02',
              'test',
            ]),
            'title': 'TEST_02 DESCRIPTION',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'small_rel_path_TEST_01': dict({
            'content': 'small_rel_path_TEST_01',
            'docname': 'subdoc/rel_path_import',
            'external_css': 'external_link',
            'id': 'small_rel_path_TEST_01',
            'is_import': True,
            'lineno': 6,
            'section_name': 'Relative path import test',
            'sections': list([
              'Relative path import test',
            ]),
            'title': 'TEST_01 DESCRIPTION',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'test_IMPL_01': dict({
            'content': 'Incoming links of this spec: :need_incoming:`test_IMPL_01`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_IMPL_01',
            'is_import': True,
            'lineno': 23,
            'links': list([
              'test_OWN_ID_123',
            ]),
            'links_back': list([
              'test_T_C3893',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
              'new_tag',
            ]),
            'title': 'Implementation for specification',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'test_OWN_ID_123': dict({
            'content': 'Outgoing links of this spec: :need_outgoing:`test_OWN_ID_123`.',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_OWN_ID_123',
            'is_import': True,
            'lineno': 23,
            'links': list([
              'test_R_F4722',
            ]),
            'links_back': list([
              'test_IMPL_01',
              'test_T_C3893',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
              'new_tag',
            ]),
            'title': 'Specification of a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'test_REQ_001': dict({
            'content': '''
              This is an awesome requirement and it includes a nice title,
              a given id, a tag and this text as description.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_REQ_001',
            'is_import': True,
            'lineno': 23,
            'links_back': list([
              'test_S_503A1',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'example',
              'imported',
              'new_tag',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'test_ROLES_REQ_1': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_ROLES_REQ_1',
            'is_import': True,
            'lineno': 23,
            'links_back': list([
              'test_ROLES_REQ_2',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
              'new_tag',
            ]),
            'title': 'Sliced Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'test_ROLES_REQ_2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_ROLES_REQ_2',
            'is_import': True,
            'lineno': 23,
            'links': list([
              'test_ROLES_REQ_1',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
              'new_tag',
            ]),
            'title': 'Butter on Bread',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'test_R_22EB2': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_R_22EB2',
            'is_import': True,
            'lineno': 23,
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'B',
              'filter',
              'imported',
              'new_tag',
            ]),
            'title': 'Requirement B',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'test_R_2A9D0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_R_2A9D0',
            'is_import': True,
            'lineno': 23,
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'A',
              'filter',
              'imported',
              'new_tag',
            ]),
            'title': 'Requirement A',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'test_R_F4722': dict({
            'content': '''
              This is my **first** requirement!!
              
              .. note:: You can use any rst code inside it :)
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_R_F4722',
            'is_import': True,
            'lineno': 23,
            'links_back': list([
              'test_OWN_ID_123',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'requirement',
              'test',
              'awesome',
              'imported',
              'new_tag',
            ]),
            'title': 'My first requirement',
            'type': 'req',
            'type_name': 'Requirement',
          }),
          'test_S_01A67': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_S_01A67',
            'is_import': True,
            'lineno': 23,
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'open',
            'tags': list([
              'B',
              'filter',
              'imported',
              'new_tag',
            ]),
            'title': 'Specification B',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'test_S_503A1': dict({
            'content': '''
              We haven't set an **ID** here, so sphinxcontrib-needs
              will generated one for us.
              
              But we have **set a link** to our first requirement and
              also a *status* is given.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_S_503A1',
            'is_import': True,
            'lineno': 23,
            'links': list([
              'test_REQ_001',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'done',
            'tags': list([
              'important',
              'example',
              'imported',
              'new_tag',
            ]),
            'title': 'Spec for a requirement',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'test_S_D70B0': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_S_D70B0',
            'is_import': True,
            'lineno': 23,
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'closed',
            'tags': list([
              'A',
              'filter',
              'imported',
              'new_tag',
            ]),
            'title': 'Specification A',
            'type': 'spec',
            'type_name': 'Specification',
          }),
          'test_TEST_01': dict({
            'content': 'TEST IMPORT TITLE',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_TEST_01',
            'is_import': True,
            'lineno': 23,
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'imported',
              'new_tag',
            ]),
            'title': 'TEST IMPORT DESCRIPTION',
            'type': 'impl',
            'type_name': 'Implementation',
          }),
          'test_T_5CCAA': dict({
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_T_5CCAA',
            'is_import': True,
            'lineno': 23,
            'parent_needs_back': list([
              'test_T_C3893',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'tags': list([
              'awesome',
              'filter',
              'imported',
              'new_tag',
            ]),
            'title': 'Test 1',
            'type': 'test',
            'type_name': 'Test Case',
          }),
          'test_T_C3893': dict({
            'content': '''
              This test checks :need:`impl_01` for :need:`test_OWN_ID_123` inside a
              Python 2.7 environment.
            ''',
            'docname': 'index',
            'external_css': 'external_link',
            'id': 'test_T_C3893',
            'is_import': True,
            'lineno': 23,
            'links': list([
              'test_IMPL_01',
              'test_OWN_ID_123',
            ]),
            'parent_need': 'test_T_5CCAA',
            'parent_needs': list([
              'test_T_5CCAA',
            ]),
            'section_name': 'TEST',
            'sections': list([
              'TEST',
              'TEST DOCUMENT IMPORT',
            ]),
            'status': 'implemented',
            'tags': list([
              'test',
              'user_interface',
              'python27',
              'imported',
              'new_tag',
            ]),
            'title': 'Test for XY',
            'type': 'test',
            'type_name': 'Test Case',
          }),
        }),
        'needs_amount': 65,
        'needs_defaults_removed': True,
        'needs_schema': dict({
          '$schema': 'http://json-schema.org/draft-07/schema#',
          'properties': dict({
            'arch': dict({
              'additionalProperties': dict({
                'type': 'string',
              }),
              'default': dict({
              }),
              'description': 'Mapping of uml key to uml content.',
              'field_type': 'core',
              'type': 'object',
            }),
            'avatar': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'closed_at': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'completion': dict({
              'default': None,
              'description': 'Added for needgantt functionality',
              'field_type': 'extra',
              'type': list([
                'integer',
                'null',
              ]),
            }),
            'constraints': dict({
              'default': list([
              ]),
              'description': 'List of constraint names, which are defined for this need.',
              'field_type': 'core',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'constraints_error': dict({
              'default': None,
              'description': 'An error message set if any constraint failed, and `error_message` field is set in config.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'constraints_passed': dict({
              'default': True,
              'description': 'True if all constraints passed, False if any failed, None if not yet checked.',
              'field_type': 'core',
              'type': list([
                'boolean',
                'null',
              ]),
            }),
            'constraints_results': dict({
              'additionalProperties': dict({
                'type': 'object',
              }),
              'default': dict({
              }),
              'description': 'Mapping of constraint name, to check name, to result, None if not yet checked.',
              'field_type': 'core',
              'type': list([
                'object',
                'null',
              ]),
            }),
            'content': dict({
              'default': '',
              'description': 'The main content of the need.',
              'field_type': 'core',
              'type': 'string',
            }),
            'created_at': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'docname': dict({
              'default': None,
              'description': 'Name of the document where the need is defined (None if external).',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'doctype': dict({
              'default': '.rst',
              'description': "The markup type of the content, denoted by the suffix of the source file, e.g. '.rst'.",
              'field_type': 'core',
              'type': 'string',
            }),
            'duration': dict({
              'default': None,
              'description': 'Added for needgantt functionality',
              'field_type': 'extra',
              'type': list([
                'integer',
                'null',
              ]),
            }),
            'external_css': dict({
              'default': '',
              'description': 'CSS class name, added to the external reference.',
              'field_type': 'core',
              'type': 'string',
            }),
            'external_url': dict({
              'default': None,
              'description': 'URL of the need, if it is an external need.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'has_dead_links': dict({
              'default': False,
              'description': 'True if any links reference need ids that are not found in the need list.',
              'field_type': 'core',
              'type': 'boolean',
            }),
            'has_forbidden_dead_links': dict({
              'default': False,
              'description': 'True if any links reference need ids that are not found in the need list, and the link type does not allow dead links.',
              'field_type': 'core',
              'type': 'boolean',
            }),
            'id': dict({
              'description': 'ID of the data.',
              'field_type': 'core',
              'type': 'string',
            }),
            'id_prefix': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'is_external': dict({
              'default': False,
              'description': 'If true, no node is created and need is referencing external url.',
              'field_type': 'core',
              'type': 'boolean',
            }),
            'is_import': dict({
              'default': False,
              'description': 'If true, the need was derived from an import.',
              'field_type': 'core',
              'type': 'boolean',
            }),
            'is_modified': dict({
              'default': False,
              'description': 'Whether the need was modified by needextend.',
              'field_type': 'core',
              'type': 'boolean',
            }),
            'jinja_content': dict({
              'default': False,
              'description': 'Whether the content was pre-processed by jinja.',
              'field_type': 'core',
              'type': 'boolean',
            }),
            'layout': dict({
              'default': None,
              'description': 'Key of the layout, which is used to render the need.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'lineno': dict({
              'default': None,
              'description': 'Line number where the need is defined (None if external).',
              'field_type': 'core',
              'type': list([
                'integer',
                'null',
              ]),
            }),
            'links': dict({
              'default': list([
              ]),
              'description': 'Link field',
              'field_type': 'links',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'links_back': dict({
              'default': list([
              ]),
              'description': 'Backlink field',
              'field_type': 'backlinks',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'max_amount': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'max_content_lines': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'modifications': dict({
              'default': 0,
              'description': 'Number of modifications by needextend.',
              'field_type': 'core',
              'type': 'integer',
            }),
            'params': dict({
              'default': None,
              'description': 'Added by service open-needs',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'parent_need': dict({
              'default': None,
              'description': 'Simply the first parent id.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'parent_needs': dict({
              'default': list([
              ]),
              'description': 'Link field',
              'field_type': 'links',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'parent_needs_back': dict({
              'default': list([
              ]),
              'description': 'Backlink field',
              'field_type': 'backlinks',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'parts': dict({
              'additionalProperties': dict({
                'type': 'object',
              }),
              'default': dict({
              }),
              'description': "Mapping of parts, a.k.a. sub-needs, IDs to data that overrides the need's data",
              'field_type': 'core',
              'type': 'object',
            }),
            'post_content': dict({
              'default': None,
              'description': 'Additional content after the need.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'post_template': dict({
              'default': None,
              'description': 'The template key, if the post_content was created from a jinja template.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'pre_content': dict({
              'default': None,
              'description': 'Additional content before the need.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'pre_template': dict({
              'default': None,
              'description': 'The template key, if the pre_content was created from a jinja template.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'prefix': dict({
              'default': None,
              'description': 'Added by service open-needs',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'query': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'section_name': dict({
              'default': None,
              'description': 'Simply the first section.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'sections': dict({
              'default': list([
              ]),
              'description': 'Sections of the need.',
              'field_type': 'core',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'service': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'signature': dict({
              'default': None,
              'description': 'Derived from a docutils desc_name node.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'specific': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'status': dict({
              'default': None,
              'description': 'Status of the need.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'style': dict({
              'default': None,
              'description': 'Comma-separated list of CSS classes (all appended by `needs_style_`).',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'tags': dict({
              'default': list([
              ]),
              'description': 'List of tags.',
              'field_type': 'core',
              'items': dict({
                'type': 'string',
              }),
              'type': 'array',
            }),
            'template': dict({
              'default': None,
              'description': 'The template key, if the content was created from a jinja template.',
              'field_type': 'core',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'title': dict({
              'description': 'Title of the need.',
              'field_type': 'core',
              'type': 'string',
            }),
            'type': dict({
              'default': '',
              'description': 'Type of the need.',
              'field_type': 'core',
              'type': 'string',
            }),
            'type_name': dict({
              'default': '',
              'description': 'Name of the type.',
              'field_type': 'core',
              'type': 'string',
            }),
            'updated_at': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'url': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'url_postfix': dict({
              'default': None,
              'description': 'Added by service open-needs',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
            'user': dict({
              'default': None,
              'description': 'Added by service github-issues',
              'field_type': 'extra',
              'type': list([
                'string',
                'null',
              ]),
            }),
          }),
          'type': 'object',
        }),
      }),
    }),
  })
# ---
# name: test_need_schema_warnings[test_app0]
  dict({
    'current_version': '1.0',
    'versions': dict({
      '1.0': dict({
        'needs': dict({
        }),
        'needs_amount': 0,
        'needs_defaults_removed': True,
      }),
    }),
  })
# ---
# name: test_needimport_needs_json_download[test_app0]
  dict({
    'IMP_TEST_101': dict({
      'arch': dict({
      }),
      'avatar': None,
      'closed_at': None,
      'collapse': False,
      'completion': None,
      'constraints': list([
      ]),
      'constraints_error': None,
      'constraints_passed': True,
      'constraints_results': dict({
      }),
      'content': 'IMP_TEST_101 DESCRIPTION',
      'created_at': None,
      'docname': 'index',
      'doctype': '.rst',
      'duration': None,
      'external_css': 'external_link',
      'external_url': None,
      'has_dead_links': False,
      'has_forbidden_dead_links': False,
      'hide': False,
      'id': 'IMP_TEST_101',
      'id_complete': 'IMP_TEST_101',
      'id_parent': 'IMP_TEST_101',
      'id_prefix': None,
      'is_external': False,
      'is_import': True,
      'is_modified': False,
      'is_need': True,
      'is_part': False,
      'jinja_content': False,
      'layout': None,
      'lineno': 14,
      'lineno_content': None,
      'links': list([
      ]),
      'links_back': list([
      ]),
      'max_amount': None,
      'max_content_lines': None,
      'modifications': 0,
      'params': None,
      'parent_need': None,
      'parent_needs': list([
      ]),
      'parent_needs_back': list([
      ]),
      'parts': dict({
      }),
      'post_content': None,
      'post_template': None,
      'pre_content': None,
      'pre_template': None,
      'prefix': None,
      'query': None,
      'section_name': 'TEST DOCUMENT NEEDIMPORT DOWNLOAD NEEDS JSON',
      'sections': tuple(
        'TEST DOCUMENT NEEDIMPORT DOWNLOAD NEEDS JSON',
      ),
      'service': None,
      'signature': None,
      'specific': None,
      'status': None,
      'style': None,
      'tags': list([
        'ext_test',
      ]),
      'template': None,
      'title': 'TEST_101 TITLE',
      'type': 'impl',
      'type_color': '#DF744A',
      'type_name': 'Implementation',
      'type_prefix': 'IM_',
      'type_style': 'node',
      'updated_at': None,
      'url': None,
      'url_postfix': None,
      'user': None,
    }),
    'SPEC_1': dict({
      'arch': dict({
      }),
      'avatar': None,
      'closed_at': None,
      'collapse': False,
      'completion': None,
      'constraints': list([
      ]),
      'constraints_error': None,
      'constraints_passed': True,
      'constraints_results': dict({
      }),
      'content': 'other.',
      'created_at': None,
      'docname': 'index',
      'doctype': '.rst',
      'duration': None,
      'external_css': 'external_link',
      'external_url': None,
      'has_dead_links': False,
      'has_forbidden_dead_links': False,
      'hide': False,
      'id': 'SPEC_1',
      'id_complete': 'SPEC_1',
      'id_parent': 'SPEC_1',
      'id_prefix': None,
      'is_external': False,
      'is_import': False,
      'is_modified': False,
      'is_need': True,
      'is_part': False,
      'jinja_content': False,
      'layout': None,
      'lineno': 9,
      'lineno_content': 12,
      'links': list([
      ]),
      'links_back': list([
      ]),
      'max_amount': None,
      'max_content_lines': None,
      'modifications': 0,
      'params': None,
      'parent_need': None,
      'parent_needs': list([
      ]),
      'parent_needs_back': list([
      ]),
      'parts': dict({
      }),
      'post_content': None,
      'post_template': None,
      'pre_content': None,
      'pre_template': None,
      'prefix': None,
      'query': None,
      'section_name': 'TEST DOCUMENT NEEDIMPORT DOWNLOAD NEEDS JSON',
      'sections': tuple(
        'TEST DOCUMENT NEEDIMPORT DOWNLOAD NEEDS JSON',
      ),
      'service': None,
      'signature': None,
      'specific': None,
      'status': None,
      'style': None,
      'tags': list([
      ]),
      'template': None,
      'title': 'A Spec',
      'type': 'spec',
      'type_color': '#FEDCD2',
      'type_name': 'Specification',
      'type_prefix': 'SP_',
      'type_style': 'node',
      'updated_at': None,
      'url': None,
      'url_postfix': None,
      'user': None,
    }),
    'STORY_1': dict({
      'arch': dict({
      }),
      'avatar': None,
      'closed_at': None,
      'collapse': False,
      'completion': None,
      'constraints': list([
      ]),
      'constraints_error': None,
      'constraints_passed': True,
      'constraints_results': dict({
      }),
      'content': 'some.',
      'created_at': None,
      'docname': 'index',
      'doctype': '.rst',
      'duration': None,
      'external_css': 'external_link',
      'external_url': None,
      'has_dead_links': False,
      'has_forbidden_dead_links': False,
      'hide': False,
      'id': 'STORY_1',
      'id_complete': 'STORY_1',
      'id_parent': 'STORY_1',
      'id_prefix': None,
      'is_external': False,
      'is_import': False,
      'is_modified': False,
      'is_need': True,
      'is_part': False,
      'jinja_content': False,
      'layout': None,
      'lineno': 4,
      'lineno_content': 7,
      'links': list([
      ]),
      'links_back': list([
      ]),
      'max_amount': None,
      'max_content_lines': None,
      'modifications': 0,
      'params': None,
      'parent_need': None,
      'parent_needs': list([
      ]),
      'parent_needs_back': list([
      ]),
      'parts': dict({
      }),
      'post_content': None,
      'post_template': None,
      'pre_content': None,
      'pre_template': None,
      'prefix': None,
      'query': None,
      'section_name': 'TEST DOCUMENT NEEDIMPORT DOWNLOAD NEEDS JSON',
      'sections': tuple(
        'TEST DOCUMENT NEEDIMPORT DOWNLOAD NEEDS JSON',
      ),
      'service': None,
      'signature': None,
      'specific': None,
      'status': None,
      'style': None,
      'tags': list([
      ]),
      'template': None,
      'title': 'A story',
      'type': 'story',
      'type_color': '#BFD8D2',
      'type_name': 'User Story',
      'type_prefix': 'US_',
      'type_style': 'node',
      'updated_at': None,
      'url': None,
      'url_postfix': None,
      'user': None,
    }),
  })
# ---