def test_data_coverage_when_quarter_not_requested(self):
        services = [
            Service(details({
                "2012-Q4 Vol.": "2,000",
                '2012-Q4 Digital vol.': '10',
                u'2012-Q4 CPT (\xa3)': "2.00",
                "2013-Q1 Vol.": "***",
                u'2013-Q1 CPT (\xa3)': "***",
                '2013-Q1 Digital vol.': '***',
                u'High-volume?': 'yes'
            })),
            Service(details({
                "2012-Q4 Vol.": "1,000",
                u'2012-Q4 CPT (\xa3)': "3.00",
                '2012-Q4 Digital vol.': '10',
                u'High-volume?': 'yes'
            })),
        ]

        dept = Department("Agency for Beautiful Code", services)

        coverage = dept.data_coverage

        assert_that(float(coverage.percentage), close_to(0.1333333, 0.001))
        assert_that(coverage.requested, is_(45))
        assert_that(coverage.provided, is_(6))
Esempio n. 2
0
    def test_should_report_id_in_xml_tag_if_one_is_provided(self):
        suite = XunitSuite("my_name")
        result = suite.to_xml(id=2)
        assert_that(result.attrib['id'], is_("2"))

        result = suite.to_xml(id=8)
        assert_that(result.attrib['id'], is_("8"))
def task_finishes_with_status(context, status):
    """Wait for task finished: status != syncing"""

    i = 0
    task_status = None
    while i < MAX_WAIT_TASK_FINISHED:
        body, response = \
            context.glancesync_api_client.get_task_api_client(context.region_name).get_task_details(context.task_id)

        assert_that(str(response.status_code), is_(equal_to("200")),
                    "HTTP Status code is for TASK request not the expected one.")

        assert_that(body, has_key('status'),
                    "The response of TASK request does not contain the expected attribute.")

        task_status = body['status']
        if task_status != "syncing":
            break

        __logger__.info("#%s Waiting for TASK final status. Status: %s", i, status)
        time.sleep(WAIT_SECONDS)
        i += 1

    assert_that(task_status, is_(equal_to(status)),
                "The task has not been successfully executed.")
def test_produce_custom_topic():
    """
    Producer delegates to SNS client.

    """
    def loader(metadata):
        return dict(
            sns_topic_arns=dict(
                default=None,
                mappings={
                    DerivedSchema.MEDIA_TYPE: "special-topic",
                },
            )
        )

    graph = create_object_graph("example", testing=True, loader=loader)
    graph.use("opaque")

    # set up response
    graph.sns_producer.sns_client.publish.return_value = dict(MessageId=MESSAGE_ID)

    message_id = graph.sns_producer.produce(DerivedSchema.MEDIA_TYPE, data="data")

    assert_that(graph.sns_producer.sns_client.publish.call_count, is_(equal_to(1)))
    assert_that(graph.sns_producer.sns_client.publish.call_args[1]["TopicArn"], is_(equal_to("special-topic")))
    assert_that(loads(graph.sns_producer.sns_client.publish.call_args[1]["Message"]), is_(equal_to({
        "data": "data",
        "mediaType": DerivedSchema.MEDIA_TYPE,
        "opaqueData": {},
    })))
    assert_that(message_id, is_(equal_to(MESSAGE_ID)))
    def test_download_datapackage(self, helpers, config,
                                  test_datapackages_path, api_client,
                                  dataset_key):
        datapackage_zip = path.join(test_datapackages_path,
                                    'the-simpsons-by-the-data.zip')
        with responses.RequestsMock() as rsps, open(datapackage_zip,
                                                    'rb') as file:
            @helpers.validate_request_headers()
            def datapackage_endpoint(_):
                return 200, {}, file.read()

            rsps.add_callback(
                rsps.GET,
                'https://download.data.world/datapackage/agentid/datasetid',
                datapackage_endpoint)

            datapackage = api_client.download_datapackage(dataset_key,
                                                          config.cache_dir)

            assert_that(datapackage, equal_to(
                path.join(config.cache_dir, 'datapackage.json')))
            assert_that(path.isfile(datapackage),
                        described_as('%0 is a file', is_(True), datapackage))

            data_subdirectory = path.join(config.cache_dir, 'data')
            assert_that(path.isdir(data_subdirectory),
                        described_as('%0 is a directory', is_(True),
                                     data_subdirectory))
            assert_that(os.listdir(config.tmp_dir),
                        described_as('%0 is empty', empty(), config.tmp_dir))
Esempio n. 6
0
    def test_get(self):
        node = NodeFactory()

        status_code, json_response = self.get({'id': node.id})

        assert_that(status_code, is_(200))
        assert_that(json_response['name'], is_(node.name))
Esempio n. 7
0
    def test_list_returns_all_if_omniscient_nd_collector_view_but_no_ownership(
            self):
        view = TestResourceViewCollector()

        request = HttpRequest()
        request.method = 'GET'
        request.META['HTTP_AUTHORIZATION'] = \
            'Bearer correct-token'

        settings.USE_DEVELOPMENT_USERS = False
        signon = govuk_signon_mock(
            permissions=['omniscient', 'collector-view'])
        with HTTMock(signon):
            response = view.get(request)

            try:
                json_response = json.loads(response.content)
            except ValueError:
                json_response = None

            assert_that(response.status_code, is_(200))
            assert_that(len(json_response), is_(2))
            assert_that(json_response, contains_inanyorder(
                has_entry("name", starts_with(
                    self.__class__.collector_type1.name)),
                has_entry("name", starts_with(
                    self.__class__.collector_type2.name))))
def test_health_check_custom_check_failed():
    """
    Should return 503 on health check failure.

    """
    loader = load_from_dict(
        health_convention=dict(
            include_build_info="false",
        ),
    )
    graph = create_object_graph(name="example", testing=True, loader=loader)
    graph.use("health_convention")

    client = graph.flask.test_client()

    def fail(graph):
        raise Exception("failure!")

    graph.health_convention.checks["foo"] = fail

    response = client.get("/api/health")
    assert_that(response.status_code, is_(equal_to(503)))
    data = loads(response.get_data().decode("utf-8"))
    assert_that(data, is_(equal_to({
        "name": "example",
        "ok": False,
        "checks": {
            "foo": {
                "message": "failure!",
                "ok": False,
            },
        },
    })))
Esempio n. 9
0
    def test_batch_last_updated(self):
        records = {
            # timestamps in ascending order
            'some_data': [
                {'_timestamp': d_tz(2018, 1, 1)},
                {'_timestamp': d_tz(2019, 1, 1)},
                {'_timestamp': d_tz(2020, 1, 1)},
            ],
            # timestamps in descending order
            'some_other_data': [
                {'_timestamp': d_tz(2017, 1, 1)},
                {'_timestamp': d_tz(2016, 1, 1)},
                {'_timestamp': d_tz(2015, 1, 1)},
            ]
        }

        for key, items in records.iteritems():
            self.engine.create_data_set(key, 0)
            for item in items:
                self.engine.save_record(key, item)

        some_data_set = DataSet(self.engine, {'name': 'some_data'})
        some_other_data_set = DataSet(self.engine, {'name': 'some_other_data'})
        yet_another_data_set = DataSet(self.engine, {'name': 'yet_another_data'})

        self.engine.batch_last_updated([some_data_set, some_other_data_set, yet_another_data_set])

        some_data_set_last_updated = some_data_set.get_last_updated()
        some_other_data_set_last_updated = some_other_data_set.get_last_updated()
        yet_another_data_set_last_updated = yet_another_data_set.get_last_updated()

        assert_that(some_data_set_last_updated, is_(d_tz(2020, 1, 1, 0, 0, 0)))
        assert_that(some_other_data_set_last_updated, is_(d_tz(2017, 1, 1, 0, 0, 0)))
        assert_that(yet_another_data_set_last_updated, is_(none()))
Esempio n. 10
0
    def test_grid_query(self):
        grid = Grid(11.0, 12.0, 51.0, 52.0, 0.1, 0.2, self.srid)
        query = self.query_builder.grid_query("<table_name>", grid, count_threshold=0,
                                              time_interval=TimeInterval(self.start_time, self.end_time))

        assert_that(str(query), is_(
            "SELECT TRUNC((ST_X(ST_Transform(geog::geometry, %(srid)s)) - %(xmin)s) / %(xdiv)s)::integer AS rx, "
            "TRUNC((ST_Y(ST_Transform(geog::geometry, %(srid)s)) - %(ymin)s) / %(ydiv)s)::integer AS ry, "
            "count(*) AS strike_count, max(\"timestamp\") as \"timestamp\" FROM <table_name> "
            "WHERE ST_GeomFromWKB(%(envelope)s, %(envelope_srid)s) && geog AND "
            "\"timestamp\" >= %(start_time)s AND \"timestamp\" < %(end_time)s GROUP BY rx, ry"))
        parameters = query.get_parameters()
        assert_that(parameters.keys(),
                    contains_inanyorder('xmin', 'ymin', 'xdiv', 'ydiv', 'envelope', 'envelope_srid', 'srid',
                                        'start_time', 'end_time'))
        assert_that(parameters.keys(), not contains_inanyorder('count_threshold'))
        assert_that(parameters['xmin'], is_(11.0))
        assert_that(parameters['ymin'], is_(51.0))
        assert_that(parameters['xdiv'], is_(0.1))
        assert_that(parameters['ydiv'], is_(0.2))
        assert_that(parameters['envelope'], is_(not_none()))
        assert_that(parameters['envelope_srid'], is_(self.srid))
        assert_that(parameters['start_time'], is_(self.start_time))
        assert_that(parameters['end_time'], is_(self.end_time))
        assert_that(parameters['srid'], is_(self.srid))
def test_health_check_custom_check():
    """
    Should return Custom health check results.

    """
    loader = load_from_dict(
        health_convention=dict(
            include_build_info="false",
        ),
    )
    graph = create_object_graph(name="example", testing=True, loader=loader)
    graph.use("health_convention")

    client = graph.flask.test_client()

    graph.health_convention.checks["foo"] = lambda graph: "hi"

    response = client.get("/api/health")
    assert_that(response.status_code, is_(equal_to(200)))
    data = loads(response.get_data().decode("utf-8"))
    assert_that(data, is_(equal_to({
        "name": "example",
        "ok": True,
        "checks": {
            "foo": {
                "message": "hi",
                "ok": True,
            },
        },
    })))
def test_float_number():
    query = {
        "id": "12345",
        "metrics": ["rate"],
        "dimensions": [],
    }
    expected_response_0 = {
        "start_date": date(2013, 4, 1),
        "end_date": date(2013, 4, 7),
        "metrics": {"rate": "23.4"},
    }

    client = mock.Mock()
    client.query.get.side_effect = [
        [expected_response_0],
    ]

    items = query_for_range(client, query, date(2013, 4, 1), date(2013, 4, 7))

    assert_that(len(items), is_(1))
    (response_0,) = items
    assert_that(response_0, is_(expected_response_0))

    (doc_0,) = build_document_set(items, "", None, None)

    assert_that(doc_0['rate'], is_(23.4))
Esempio n. 13
0
    def test_bent_vertical(self):
        """
        Test that horizontal corridor with bend can be made
        """
        edge_connection = Connection(connection=None,
                                     location=(9, 0),
                                     direction="down",
                                     section=self.section)

        room_connection = Connection(connection=None,
                                     location=(2, 9),
                                     direction="up",
                                     section=self.section)

        add_section_connection(self.section, edge_connection)
        add_room_connection(self.section, (2, 9), "up")

        generator = CorridorGenerator(start_point=edge_connection,
                                      end_point=room_connection,
                                      wall_tile=None,
                                      floor_tile=self.floor_rock)

        generator.generate()

        assert_that(wall_tile(self.level, (9, 0)),
                    is_(equal_to(None)))
        assert_that(wall_tile(self.level, (2, 9)),
                    is_(equal_to(None)))
        assert_that(self.level, is_fully_accessible())
def test_error_wrap():
    """
    Wrapped errors work properly.

    """
    graph = create_object_graph(name="example", testing=True)

    def fail():
        raise Exception("fail")

    @graph.app.route("/wrap")
    @graph.audit
    def wrap():
        try:
            fail()
        except Exception as error:
            raise Exception(error)

    client = graph.app.test_client()

    response = client.get("/wrap")
    assert_that(response.status_code, is_(equal_to(500)))
    data = response.json
    assert_that(data, is_(equal_to({
        "code": 500,
        "message": "fail",
        "retryable": False,
        "context": {"errors": []}
    })))
def test_werkzeug_http_error():
    """
    Explicit HTTP errors are reported as expected.

    """
    graph = create_object_graph(name="example", testing=True)

    @graph.app.route("/not_found")
    @graph.audit
    def not_found():
        raise NotFound

    client = graph.app.test_client()

    response = client.get("/not_found")
    assert_that(response.status_code, is_(equal_to(404)))
    data = response.json
    assert_that(data, is_(equal_to({
        "code": 404,
        "context": {
            "errors": [],
        },
        "message": "The requested URL was not found on the server. "
                   "If you entered the URL manually please check your spelling and try again.",
        "retryable": False,
    })))
    def test_compare_configuration(self):

        result = self.nc.compare_configuration()

        output = result.xpath("configuration-information/configuration-output")[0]
        assert_that(output.text.strip(), is_(""))

        self.edit({
            "vlans": [
                {"vlan": [
                    {"name": "VLAN2995"},
                    {"vlan-id": "2995"}]},
            ]})

        result = self.nc.compare_configuration()

        output = result.xpath("configuration-information/configuration-output")[0]
        assert_that(output.text.strip(), is_not(""))

        self.nc.commit()

        result = self.nc.compare_configuration()

        output = result.xpath("configuration-information/configuration-output")[0]
        assert_that(output.text.strip(), is_(""))
def test_custom_error_retryable():
    """
    Custom errors status codes are handled as expected.

    """
    graph = create_object_graph(name="example", testing=True)

    @graph.app.route("/conflict")
    @graph.audit
    def conflict():
        raise MyConflictError("Conflict")

    client = graph.app.test_client()

    response = client.get("/conflict")
    assert_that(response.status_code, is_(equal_to(409)))
    data = response.json
    assert_that(data, is_(equal_to({
        "code": 409,
        "message": "Conflict",
        "retryable": True,
        "context": {
            "errors": [{
                "message": "Banana!",
            }]
        },
    })))
Esempio n. 18
0
    def test_get_component_hierarchy(self, fake_find):
        # This is a lousy test, just testing what we already see done, not
        # correct behaviour
        pers_comps = BaseComponents(BASE, 'persistent', (BASE,))

        class MockSite(object):
            __parent__ = None
            __name__ = None

            def __init__(self):
                self.__parent__ = {}

        site_comps_1 = BaseComponents(pers_comps, '1', (pers_comps,))
        site_comps_2 = BaseComponents(site_comps_1, '2', (site_comps_1,))

        site = MockSite()
        site.__parent__[site_comps_1.__name__] = site_comps_1
        site.__parent__[site_comps_2.__name__] = site_comps_2

        fake_find.is_callable().returns(site_comps_2)

        x = list(get_component_hierarchy(site))
        assert_that(x, is_([site_comps_2, site_comps_1]))

        x = list(get_component_hierarchy_names(site))
        assert_that(x, is_(['2', '1']))

        x = list(get_component_hierarchy_names(site, reverse=True))
        assert_that(x, is_(['1', '2']))
Esempio n. 19
0
    def _store_base_subs_in_zodb(self, storage):
        db = DB(storage)
        conn = db.open()

        base_comps = BLSM(None)
        base_comps.btree_threshold = 0
        base_comps.__name__ = u'base'
        # replace with "broken"
        base_comps.adapters = _LocalAdapterRegistry()
        base_comps.utilities = _LocalAdapterRegistry()

        sub_comps = BLSM(None)
        sub_comps.__name__ = u'sub'
        sub_comps.__bases__ = (base_comps,)

        assert_that(sub_comps.adapters.__bases__, is_((base_comps.adapters,)))
        assert_that(sub_comps.utilities.__bases__, is_((base_comps.utilities,)))
        assert_that(sub_comps.utilities.__bases__[0], is_(_LocalAdapterRegistry))

        conn.root()['base'] = base_comps
        conn.root()['sub'] = sub_comps


        transaction.commit()
        conn.close()
        db.close()
Esempio n. 20
0
    def test_portal_has_icons(self):
        """
        Test that portal created by adder has two icons set
        One to display and another to be used by opposite end
        """
        level = (LevelBuilder()
                 .with_size((20, 20))
                 .with_floor_tile(self.floor_rock)
                 .with_wall_tile(self.wall_empty)
                 .build())

        level_generator = mock()

        for loc_y in range(8, 12):
            for loc_x in range(8, 12):
                add_location_tag(level, (loc_x, loc_y), 'room')

        portal_adder = PortalAdder((1, 2),
                                   'room',
                                   level_generator,
                                   False,
                                   self.rng)

        portal_adder.add_portal(level)

        portals = []
        for loc_y in range(8, 12):
            for loc_x in range(8, 12):
                temp = get_portal(level, (loc_x, loc_y))
                if temp:
                    portals.append(temp)
        portal = portals[0]

        assert_that(portal.icon, is_(equal_to(1)))
        assert_that(portal.other_end_icon, is_(equal_to(2)))
def test_configure_engine():
    """
    Engine factory should work with zero configuration.

    """
    graph = create_object_graph(name="example", testing=True)
    engine = graph.postgres

    assert_that(engine, is_(instance_of(Engine)))

    # engine has expected configuration
    assert_that(
        str(engine.url),
        starts_with("postgresql://example:@"),
    )

    assert_that(
        str(engine.url),
        ends_with(":5432/example_test_db"),
    )

    # engine supports connections
    with engine.connect() as connection:
        row = connection.execute("SELECT 1;").fetchone()
        assert_that(row[0], is_(equal_to(1)))
Esempio n. 22
0
def _key_is_stored_in_the_server_helper(context, keyfile_name, keyfile_content):
    """
    Step HELPER. Check if the given keyfile is stored in the server. Performe assertions.
    :param context: Context
    :param keyfile_name (string): File name with the key to be uploaded. e.i. 'Spain2.sshkey'
    :param keyfile_conent (string): The file with the content (key value) to be checked. e.i 'Spain2b.sshkey'
    :return: None
    """

    aiakos_keyfile_path = configuration_manager.config[PROPERTIES_CONFIG_AIAKOS][PROPERTIES_CONFIG_AIAKOS_KEYFILES_PATH]

    # Assert: Remote file exists
    if aiakos_keyfile_path == "":
        result = True
    else:
        result = context.remote_executor.file_exist(aiakos_keyfile_path, keyfile_name)

    assert_that(
        result, is_(True), "Remote file '{}/{}' does not exist in remote host".format(aiakos_keyfile_path, keyfile_name)
    )

    # Assert: Content of the remote file is the expected one
    ssh_key_filepath = os.path.join(RESOURCES_PATH, keyfile_content)
    with open(ssh_key_filepath, "r") as file_content:
        if aiakos_keyfile_path == "":
            result = True
        else:
            result = context.remote_executor.content_in_file(aiakos_keyfile_path, keyfile_name, file_content.read())
        assert_that(
            result,
            is_(True),
            "Remote file '{}/{}' does not contains the expected key".format(aiakos_keyfile_path, keyfile_name),
        )
Esempio n. 23
0
    def test_fix_timezone(self):
        assert_that(self.base.fix_timezone(None), is_(none()))

        time = datetime.datetime(2013, 1, 1, 12, 0, 0, tzinfo=pytz.timezone("CET"))
        utc_time = datetime.datetime(2013, 1, 1, 11, 0, 0, tzinfo=pytz.timezone("UTC"))

        assert_that(self.base.fix_timezone(time), is_(utc_time))
def test_discovery():
    graph = create_object_graph(name="example", testing=True)
    graph.use("discovery_convention")

    ns = Namespace("foo")

    @graph.route(ns.collection_path, Operation.Search, ns)
    def search_foo():
        pass

    client = graph.flask.test_client()

    response = client.get("/api")
    assert_that(response.status_code, is_(equal_to(200)))
    data = loads(response.get_data().decode("utf-8"))
    assert_that(data, is_(equal_to({
        "_links": {
            "search": [{
                "href": "http://localhost/api/foo?offset=0&limit=20",
                "type": "foo",
            }],
            "self": {
                "href": "http://localhost/api?offset=0&limit=20",
            },
        }
    })))
Esempio n. 25
0
def step_then_auto_shape_appears_in_slide(context):
    prs = Presentation(saved_pptx_path)
    sp = prs.slides[0].shapes[0]
    sp_text = sp.textframe.paragraphs[0].runs[0].text
    assert_that(sp.shape_type, is_(equal_to(MSO.AUTO_SHAPE)))
    assert_that(sp.auto_shape_type, is_(equal_to(MAST.ROUNDED_RECTANGLE)))
    assert_that(sp_text, is_(equal_to(test_text)))
Esempio n. 26
0
    def test_get_raw_data_since(self):
        last_data = datetime.datetime.utcnow() - datetime.timedelta(hours=1)

        self.data_url.build_path.side_effect = ['full_url1', 'full_url2']
        self.url_path_generator.get_paths.return_value = ['url_path1', 'url_path2']
        self.data_provider.read_lines.side_effect = [["line11", "line12"], ["line21", "line22"]]
        raw11 = Mock(name='raw11')
        raw12 = Mock(name='raw12')
        raw21 = Mock(name='raw21')
        raw22 = Mock(name='raw22')
        self.builder.from_string.return_value = self.builder
        self.builder.build.side_effect = [raw11, raw12, raw21, raw22]

        region_id = 5
        station_id = 123
        raw_signals = list(self.provider.get_raw_data_since(last_data, region_id, station_id))

        expected_args = [call(last_data)]
        assert_that(self.url_path_generator.get_paths.call_args_list, is_(equal_to(expected_args)))

        expected_args = [
            call('{}/url_path1'.format(station_id), region=region_id, host_name='signals'),
            call('{}/url_path2'.format(station_id), region=region_id, host_name='signals')]
        assert_that(self.data_url.build_path.call_args_list, is_(equal_to(expected_args)))

        expected_args = [call('full_url1'), call('full_url2')]
        assert_that(self.data_provider.read_lines.call_args_list, is_(equal_to(expected_args)))

        assert_that(raw_signals, contains(raw11, raw12, raw21, raw22))
Esempio n. 27
0
def test_object():
    """
    Can create a class for an object schema.
    """
    registry = Registry()
    registry.load(schema_for("data/name.json"))

    Name = registry.create_class(NAME_ID)

    name = Name(
        first="George",
    )

    assert_that(calling(name.validate), raises(ValidationError))

    name.last = "Washington"

    name.validate()

    assert_that(
        name,
        has_properties(
            first=equal_to("George"),
            last=equal_to("Washington"),
        )
    )
    assert_that(name, is_(equal_to(NAME)))
    assert_that(name, is_(equal_to(Name(**NAME))))
    assert_that(Name.loads(name.dumps()), is_(equal_to(name)))

    del name.first

    assert_that(calling(name.validate), raises(ValidationError))
def test_from_name():
    """
    Operations can be looked up by name.

    """
    assert_that(Operation.from_name("search"), is_(equal_to(Operation.Search)))
    assert_that(Operation.from_name("Create"), is_(equal_to(Operation.Create)))
    def test_GIVEN_categories_have_land_cover_regions_WHEN_get_categories_THEN_category_has_regions_loaded(self):
        model_run = self.model_run_service.get_model_being_created_with_non_default_parameter_values(self.user)

        with session_scope() as session:
            cat1 = LandCoverRegionCategory()
            cat1.name = "Countries"
            cat1.driving_dataset_id = model_run.driving_dataset_id

            region1 = LandCoverRegion()
            region1.mask_file = "filepath"
            region1.name = "Wales"
            region1.category = cat1

            cat2 = LandCoverRegionCategory()
            cat2.name = "Rivers"
            cat2.driving_dataset_id = model_run.driving_dataset_id

            region2 = LandCoverRegion()
            region2.mask_file = "filepath2"
            region2.name = "Thames"
            region2.category = cat2

            session.add_all([region1, region2])

        categories = self.land_cover_service.get_land_cover_categories(model_run.driving_dataset_id)
        assert_that(len(categories[0].regions), is_(1))
        assert_that(categories[0].regions[0].name, is_("Wales"))
Esempio n. 30
0
 def test_GIVEN_attributes_WHEN_calculate_gridded_THEN_attributes_set_on_output(self):
     self._make_two_gridded()
     expr = 'var1 + var2'
     attributes = {'att1': 'val1', 'att2': 'val2'}
     res = self.calc.evaluate(self.data, expr, attributes=attributes)
     assert_that(res.attributes['att1'], is_('val1'))
     assert_that(res.attributes['att2'], is_('val2'))
Esempio n. 31
0
 def test_is_trap_by_rule3(self):
     assert_that(is_trap(TRAP + SAFE + SAFE), is_(True))
Esempio n. 32
0
 def test_row_craft6(self):
     assert_that(craft_row(".^^^^.^^.^"), is_("^^..^.^^.."))
Esempio n. 33
0
 def test_row_craft5(self):
     assert_that(craft_row("..^^...^^^"), is_(".^^^^.^^.^"))
Esempio n. 34
0
 def test_get_3_tiles_limits(self):
     assert_that(tiles(".^.", -1, 1), is_("..^"))
     assert_that(tiles(".^.", 1, 3), is_("^.."))
Esempio n. 35
0
 def test_get_3_tiles_middle(self):
     assert_that(tiles(".^.", 0, 2), is_(".^."))
     assert_that(tiles("^.^.^", 1, 3), is_(".^."))
Esempio n. 36
0
 def test_is_safe(self):
     assert_that(is_trap(SAFE + SAFE + SAFE), is_(False))
     assert_that(is_trap(TRAP + TRAP + TRAP), is_(False))
     assert_that(is_trap(TRAP + SAFE + TRAP), is_(False))
Esempio n. 37
0
 def test_is_trap_by_rule4(self):
     assert_that(is_trap(SAFE + SAFE + TRAP), is_(True))
Esempio n. 38
0
    def test_dont(self):
        self.registry["a"] = 0
        move = JumpOnPositive()(self.registry, Var(self.registry, "a"),
                                Scalar(3))

        assert_that(move, is_(None))
Esempio n. 39
0
 def test(self):
     self.registry["a"] = 5
     MultiplyValue()(self.registry, Var(self.registry, "a"), Scalar(5))
     assert_that(self.registry["a"], is_(25))
Esempio n. 40
0
 def test_official(self):
     assert_that(compute(".^^.^.^^^^", rows=10), is_(38))
Esempio n. 41
0
 def test(self):
     AddValue()(self.registry, Var(self.registry, "a"), Scalar(1))
     AddValue()(self.registry, Var(self.registry, "a"), Scalar(1))
     assert_that(self.registry["a"], is_(2))
Esempio n. 42
0
 def test(self):
     self.registry["a"] = 5
     ModValue()(self.registry, Var(self.registry, "a"), Scalar(3))
     assert_that(self.registry["a"], is_(2))
Esempio n. 43
0
 def test(self):
     queue = deque()
     Send(queue)(self.registry, Scalar(1))
     assert_that(queue.popleft(), is_(1))
Esempio n. 44
0
 def test(self):
     SubValue()(self.registry, Var(self.registry, "a"), Scalar(1))
     SubValue()(self.registry, Var(self.registry, "a"), Scalar(1))
     assert_that(self.registry["a"], is_(-2))
Esempio n. 45
0
    def test_optional(self):
        validate = is_dict_with(mybool=optional(is_type(bool)))

        assert_that(validate("{}"), is_({}))
Esempio n. 46
0
 def test(self):
     queue = deque((13, ))
     Receive(queue)(self.registry, Var(self.registry, "a"))
     assert_that(self.registry["a"], is_(13))
Esempio n. 47
0
    def test_empty(self):
        validate = is_dict_with()

        assert_that(validate("{}"), is_({}))
Esempio n. 48
0
    def test_do_negative(self):
        self.registry["a"] = -5
        move = JumpOnNonZero()(self.registry, Var(self.registry, "a"),
                               Scalar(3))

        assert_that(move, is_(3))
Esempio n. 49
0
def test_links_empty():
    links = Links()
    assert_that(links.to_dict(), is_(equal_to({})))
Esempio n. 50
0
    def test_one_boolean(self):
        validate = is_dict_with(mybool=is_type(bool))
        data = {"mybool": True}

        assert_that(validate(json.dumps(data)), is_(data))
Esempio n. 51
0
def test_is_not_empty_when_holding_tags():
    metadata = Metadata()
    metadata["artist"] = "John Doe"
    metadata.addImage("img/jpeg", "...")
    assert_that(metadata.empty(), is_(False), "emptiness")
Esempio n. 52
0
def test_link_to_dict():
    link = Link(href="href", )
    assert_that(link.to_dict(), is_(equal_to({
        "href": "href",
    })))
Esempio n. 53
0
def test_is_initially_empty():
    metadata = Metadata()
    assert_that(metadata, empty(), "tags")
    assert_that(list(metadata.images), empty(), "images")
    assert_that(metadata.empty(), is_(True), "emptiness")
Esempio n. 54
0
def test_is_empty_when_cleared():
    metadata = Metadata()
    metadata["artist"] = "John Doe"
    metadata.addImage("img/jpeg", "...")
    metadata.clear()
    assert_that(metadata.empty(), is_(True), "emptiness")
Esempio n. 55
0
 def _assert_equal(normalized_uri, expected):
     assert_that(normalized_uri, is_(equal_to(expected)))
Esempio n. 56
0
def test_is_not_empty_when_containing_images():
    metadata = Metadata()
    metadata.addImage("img/jpeg", "...")
    assert_that(metadata.empty(), is_(False), "emptiness")
Esempio n. 57
0
    def test_swagger_path(self):
        with self.graph.app.test_request_context():
            path = build_path(Operation.CreateCollection, self.ns)

        assert_that(path, is_(equal_to("/api/foo")))
Esempio n. 58
0
def test_uri_load():
    schema = URISchema(strict=True)
    result = schema.load(dict(
        foo="http://example.com",
    ))
    assert_that(result.data["foo"], is_(equal_to("http://example.com")))
Esempio n. 59
0
    def test_create_collection_url(self):
        with self.graph.app.test_request_context():
            url = self.ns.url_for(Operation.CreateCollection)

        assert_that(url, is_(equal_to("http://localhost/api/foo")))
Esempio n. 60
0
 def test_returns_an_interface(self):
     interface = self.client.get_interface(self.test_ports[0].name)
     assert_that(interface.name, is_(self.test_ports[0].name))