コード例 #1
0
ファイル: mixins.py プロジェクト: alon-sage/gcore_test
    def setUp(self):
        super(HallSetupMixin, self).setUp()

        self.hall_100 = Hall.objects.create(
            name='Hall 100',
            rows_number=10,
            seats_per_row=10,
        )
        self.hall_100_url = make_url_of_model(self.hall_100)
        self.hall_100_url_match = ends_with(self.hall_100_url)
        self.hall_100_match = has_entries(
            url=self.hall_100_url_match,
            name='Hall 100',
            rows_number=10,
            seats_per_row=10,
            capacity=100,
        )

        self.hall_400 = Hall.objects.create(
            name='Hall 400',
            rows_number=20,
            seats_per_row=20,
        )
        self.hall_400_url = make_url_of_model(self.hall_400)
        self.hall_400_url_match = ends_with(self.hall_400_url)
        self.hall_400_match = has_entries(
            url=self.hall_400_url_match,
            name='Hall 400',
            rows_number=20,
            seats_per_row=20,
            capacity=400,
        )
コード例 #2
0
ファイル: report.py プロジェクト: i-feofilaktov/allure-python
def has_test_case(name, *matchers):
    return has_property(
        'test_cases',
        has_item(
            all_of(
                any_of(has_entry('fullName', ends_with(name)),
                       has_entry('name', ends_with(name))), *matchers)))
コード例 #3
0
ファイル: mixins.py プロジェクト: alon-sage/gcore_test
    def setUp(self):
        super(MovieSetupMixin, self).setUp()

        self.movie_unused = Movie.objects.create(
            name='The Disaster Artist',
            duration=104,
        )
        self.movie_unused_url = make_url_of_model(self.movie_unused)
        self.movie_unused_url_match = ends_with(self.movie_unused_url)
        self.movie_unused_match = has_entries(
            url=self.movie_unused_url_match,
            name='The Disaster Artist',
            duration=104,
        )

        self.movie_90 = Movie.objects.create(name='Movie 90', duration=90)
        self.movie_90_url = make_url_of_model(self.movie_90)
        self.movie_90_url_match = ends_with(self.movie_90_url)
        self.movie_90_match = has_entries(
            url=self.movie_90_url_match,
            name='Movie 90',
            duration=90,
        )

        self.movie_120 = Movie.objects.create(name='Movie 120', duration=120)
        self.movie_120_url = make_url_of_model(self.movie_120)
        self.movie_120_url_match = ends_with(self.movie_120_url)
        self.movie_120_match = has_entries(
            url=self.movie_120_url_match,
            name='Movie 120',
            duration=120,
        )
コード例 #4
0
ファイル: report.py プロジェクト: yuecloud/allure-python
def has_only_n_test_cases(name, num, *matchers):
    return has_property(
        'test_cases',
        ContainsExactly(
            num,
            all_of(
                any_of(has_entry('fullName', ends_with(name)),
                       has_entry('name', ends_with(name))), *matchers)))
コード例 #5
0
ファイル: mixins.py プロジェクト: alon-sage/gcore_test
    def setUp(self):
        super(MovieSessionSetupMixin, self).setUp()

        self.movie_session_past = MovieSession.objects.create(
            hall=self.hall_100,
            movie=self.movie_90,
            date=(timezone.now() - timedelta(days=1)).date(),
            starts_at=time(8),
            ticket_cost=100.0,
        )
        self.movie_session_past_cost_str = '100.00'
        self.movie_session_past_url = make_url_of_model(
            self.movie_session_past)
        self.movie_session_past_url_match = ends_with(
            self.movie_session_past_url, )
        self.movie_session_past_match = has_entries(
            url=self.movie_session_past_url_match,
            hall=self.hall_100_url_match,
            movie=self.movie_90_url_match,
        )

        self.movie_session_100_90 = MovieSession.objects.create(
            hall=self.hall_100,
            movie=self.movie_90,
            date=(timezone.now() + timedelta(days=1)).date(),
            starts_at=time(8),
            ticket_cost=100.0,
        )
        self.movie_session_100_90_cost_str = '100.00'
        self.movie_session_100_90_url = make_url_of_model(
            self.movie_session_100_90, )
        self.movie_session_100_90_url_match = ends_with(
            self.movie_session_100_90_url, )
        self.movie_session_100_90_match = has_entries(
            url=self.movie_session_100_90_url_match,
            hall=self.hall_100_url_match,
            movie=self.movie_90_url_match,
        )

        self.movie_session_400_120 = MovieSession.objects.create(
            hall=self.hall_400,
            movie=self.movie_120,
            date=(timezone.now() + timedelta(days=1)).date(),
            starts_at=time(12),
            ticket_cost=150,
        )
        self.movie_session_400_120_cost_str = '150.00'
        self.movie_session_400_120_url = make_url_of_model(
            self.movie_session_400_120, )
        self.movie_session_400_120_url_match = ends_with(
            self.movie_session_400_120_url, )
        self.movie_session_400_120_match = has_entries(
            url=self.movie_session_400_120_url_match,
            hall=self.hall_400_url_match,
            movie=self.movie_120_url_match,
        )
コード例 #6
0
    def test_that_a_token_has_a_remote_address_and_user_agent(self):
        ua = 'My Test Runner'

        post_result = self.client.token.new(expiration=1, user_agent=ua)
        assert_that(post_result,
                    has_entries(user_agent=ua, remote_addr=ends_with('.1')))
        # Docker host address are always X.X.X.1

        get_result = self.client.token.get(post_result['token'])
        assert_that(get_result,
                    has_entries(user_agent=ua, remote_addr=ends_with('.1')))
コード例 #7
0
def has_only_n_test_cases(name, num, *matchers):
    return has_property('test_cases',
                        ContainsExactly(num,
                                        all_of(
                                            any_of(
                                                has_entry('fullName', ends_with(name)),
                                                has_entry('name', ends_with(name))
                                            ),
                                            *matchers
                                        )
                                        )
                        )
コード例 #8
0
ファイル: test_main.py プロジェクト: akaIDIOT/Digestive
def test_main():
    with patch('builtins.print') as mocked_print:
        arguments = ['--hashes', '--output', '/dev/null', path.join(here, 'files/empty'), path.join(here, 'files/1234')]
        main(arguments)
        # assert a few of the prints that should have been made
        mocked_print.assert_any_call('{} ({})'.format(path.join(here, 'files/empty'), '0 bytes'), flush=True)
        mocked_print.assert_any_call('  sha256       e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855')
        mocked_print.assert_any_call('{} ({})'.format(path.join(here, 'files/1234'), '4 bytes'), flush=True)
        mocked_print.assert_any_call('  sha256       9f64a747e1b97f131fabb6b447296c9b6f0201e79fb3c5356e6c77e89b6a806a')

    four_bytes_output = {
        'source': eq(ends_with('files/1234')),
        'size': 4,
        'completed': ANY,
        'md5': '08d6c05a21512a79a1dfeb9d2a8f262f',
        'sha1': '12dada1fff4d4787ade3333147202c3b443e376f',
        'sha256': '9f64a747e1b97f131fabb6b447296c9b6f0201e79fb3c5356e6c77e89b6a806a',
        'sha512': 'a7c976db1723adb41274178dc82e9b777941ab201c69de61d0f2bc6d27a3598f594fa748e50d88d3c2bf1e2c2e72c3cfef78c3c6d4afa90391f7e33ababca48e',
    }
    random_dd_output = {
        'source': eq(ends_with('files/random.dd')),
        'size': 1048576,
        'completed': eq(instance_of(datetime)),
        'md5': '257f5c2913ea856cb0a2313f167452d4',
        'sha1': '2f8a9e749cc8e46bebe602827228e76611346f54',
        'sha256': '810ec5f2086379f0e8000456dbf2aede8538fbc9d9898835f114c8771ed834b5',
        'sha512': '24dbb6cb56757a621fb8e6a8c8733f1cfc3c77bd23ac325e672eaaf856eac602307541ac434f598afb62448e90b3608344cfeb2e64778d3f7024bc69f5bb46ef',
    }

    if sha3_available:
        four_bytes_output['sha3-256'] = '966dbdcbd0e0348faa1ccbce5a62b8e73b0d08955d666db82243b303d9bd9502'
        random_dd_output['sha3-256'] = 'f704f27aaf0d689f02917be02c1e873abefab54b9b517bcdf3d868569d6b2e65'

    with patch('builtins.print'), patch('digestive.main.output_to_file') as output:
        output_generator = MagicMock()
        output.return_value = output_generator
        # force raw format to treat random.E01 as a regular file (courtesy of Travis…)
        arguments = ['--hashes', '--recursive', '--output', '/dev/null', path.join(here, 'files')]
        main(arguments)
        # assert recursing into files and processing the test files, posting results to output
        output.assert_called_with('/dev/null')
        output_generator.send.assert_has_calls([
            # initial info call
            call({'digestive': '0.1', 'started': ANY}),
            # hashes of tests/files/1234
            call(four_bytes_output),
            # hashes of tests/files/random.dd
            call(random_dd_output)
        ], any_order=True)
コード例 #9
0
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)))
コード例 #10
0
def LanguageServerCompleter_Diagnostics_PercentEncodeCannonical_test():
  completer = MockCompleter()
  filepath = os.path.realpath( '/foo?' )
  uri = lsp.FilePathToUri( filepath )
  assert_that( uri, ends_with( '%3F' ) )
  request_data = RequestWrap( BuildRequest( line_num = 1,
                                            column_num = 1,
                                            filepath = filepath,
                                            contents = '' ) )
  notification = {
    'jsonrpc': '2.0',
    'method': 'textDocument/publishDiagnostics',
    'params': {
      'uri': uri.replace( '%3F', '%3f' ),
      'diagnostics': [ {
        'range': {
          'start': { 'line': 3, 'character': 10 },
          'end': { 'line': 3, 'character': 11 }
        },
        'severity': 1,
        'message': 'First error'
      } ]
    }
  }
  completer.GetConnection()._notifications.put( notification )
  completer.HandleNotificationInPollThread( notification )

  with patch.object( completer, 'ServerIsReady', return_value = True ):
    completer.SendInitialize(
      request_data,
      completer._GetSettingsFromExtraConf( request_data ) )
    # Simulate receipt of response and initialization complete
    initialize_response = {
      'result': {
        'capabilities': {}
      }
    }
    completer._HandleInitializeInPollThread( initialize_response )

    diagnostics = contains(
      has_entries( {
        'kind': equal_to( 'ERROR' ),
        'location': LocationMatcher( filepath, 4, 11 ),
        'location_extent': RangeMatcher( filepath, ( 4, 11 ), ( 4, 12 ) ),
        'ranges': contains(
           RangeMatcher( filepath, ( 4, 11 ), ( 4, 12 ) ) ),
        'text': equal_to( 'First error' ),
        'fixit_available': False
      } )
    )

    assert_that( completer.OnFileReadyToParse( request_data ), diagnostics )

    assert_that(
      completer.PollForMessages( request_data ),
      contains( has_entries( {
        'diagnostics': diagnostics,
        'filepath': filepath
      } ) )
    )
コード例 #11
0
def test_select_by_testcase_id_test(ids, expected_tests, allured_testdir):
    """
    >>> import allure

    >>> @allure.id("1")
    ... def test_number_one():
    ...     pass

    >>> @allure.id("2")
    ... def test_number_two():
    ...     pass

    >>> @allure.id("3")
    ... @allure.id("3+")
    ... def test_number_three():
    ...     pass

    >>> def test_without_number():
    ...     pass
    """
    allured_testdir.parse_docstring_source()

    if ids:
        py_path = allured_testdir.testdir.makefile(".json", json.dumps(ids))
        os.environ["AS_TESTPLAN_PATH"] = py_path.strpath
    else:
        del os.environ["AS_TESTPLAN_PATH"]

    allured_testdir.run_with_allure()
    test_cases = [test_case["fullName"] for test_case in allured_testdir.allure_report.test_cases]
    assert_that(test_cases, only_contains(
        any_of(
            *[ends_with(name) for name in expected_tests]
        )
    ))
コード例 #12
0
    def test_http_error_from_backdrop_flashes_message(self,
                                                      data_set_post_patch,
                                                      is_virus_patch,
                                                      get_data_set_patch,
                                                      client):
        is_virus_patch.return_value = False
        get_data_set_patch.return_value = {
            'data_group': 'carers-allowance',
            'data_type': 'volumetrics',
            'bearer_token': 'abc123',
            'foo': 'bar'
        }

        data_set_post_patch.side_effect = backdrop_response(401, {})
        post_data = {
            'file': (StringIO('_timestamp,foo\n2014-08-05T00:00:00Z,40'),
                     'MYSPECIALFILE.csv')
        }
        response = client.post('/upload-data/carers-allowance/volumetrics',
                               data=post_data)

        assert_that(
            self.get_from_session('upload_data')['payload'],
            equal_to(['[401] {}']))
        assert_that(response.headers['Location'], ends_with('/upload-data'))
        assert_that(response.status_code, equal_to(302))
コード例 #13
0
    def test_should_raise_exception_when_trying_to_use_matcher_as_second_keyword_argument_in_native_verification(
            self):

        test_object = Mock(targetpackage.TheClass())

        test_object.some_method(1, 2, 3, hello='world')

        exception_raised = False
        try:
            verify(test_object).some_method(1,
                                            2,
                                            3,
                                            hello='world',
                                            world=ANY_VALUE)
        except VerificationError as error:
            exception_raised = True
            assert_that(
                str(error),
                ends_with("""
          Please configure your mock using fluentmock.when in order
          to be able to use matchers!

"""))

        assert_that(exception_raised)
コード例 #14
0
    def test_redirect_to_error_if_problems_and_prevent_post(
            self,
            data_set_post_patch,
            validate_patch,
            get_data_set_patch,
            client):
        validate_patch.return_value = ["99"]
        get_data_set_patch.return_value = {
            'data_group': 'carers-allowance',
            'data_type': 'volumetrics',
            'bearer_token': 'abc123', 'foo': 'bar'
        }

        post_data = {
            'file':
                (StringIO('_timestamp,foo\n2014-08-05T00:00:00Z,40'),
                    'MYSPECIALFILE.csv')
        }
        response = client.post(
            '/upload-data/carers-allowance/volumetrics',
            data=post_data)

        assert_that(
            self.get_from_session('upload_data')['payload'],
            equal_to(['99']))
        assert_that(response.headers['Location'], ends_with('/upload-data'))
        assert_that(response.status_code, equal_to(302))
        assert_that(data_set_post_patch.called, equal_to(False))
コード例 #15
0
 def test_redirects_to_channel_options_page(self, mock_get_dashboard):
     response = self.client.post(
         '/dashboard/dashboard-uuid/digital-take-up/upload-options',
         data=self.params())
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/channel-options'))
コード例 #16
0
    def test_save_and_continue_button_for_update(self,
                                                 update_mock,
                                                 mock_list_organisations,
                                                 mock_list_data_sets,
                                                 mock_list_module_types):
        with self.client.session_transaction() as session:
            session['oauth_token'] = {'access_token': 'token'}
            session['oauth_user'] = {
                'permissions': ['signin', 'admin']
            }

        data = valid_dashboard_data({
            'save_and_continue':'',
        })

        resp = self.client.post(
            '/admin/dashboards/uuid', data=data)

        assert_that(resp.status_code, equal_to(302))
        assert_that(
            resp.headers['Location'],
            ends_with('/admin/dashboards/uuid'))
        expected_flash = 'Updated the <a href="http://spotlight.development' +\
            '.performance.service.gov.uk/performance/valid-slug">' + \
            'My valid title</a> dashboard'
        self.assert_flashes(expected_flash, expected_category='success')
    def test_continues_if_add_module_fails(
            self, add_module_to_dashboard_patch, list_module_types_patch,
            create_data_group_patch, get_data_group_patch,
            get_module_config_patch, create_data_set_patch, get_data_set_patch,
            get_dashboard_patch, client):

        get_module_config_patch.return_value = {
            'title': 'Cost per transaction'
        }

        get_dashboard_patch.return_value = {'slug': 'visas'}

        get_data_set_patch.return_value = {
            'name': 'apply_uk_visa_transactions_by_channel',
            'data_type': 'transactions-by-channel',
            'data_group': 'apply-uk-visa',
            'bearer_token': 'abc123',
            'upload_format': 'csv',
            'auto_ids': '_timestamp, period, channel',
            'max_age_expected': 1300000
        }
        get_data_group_patch.return_value = {'name': 'visas'}
        list_module_types_patch.return_value = [{
            'name': 'single_timeseries',
            'id': 'uuid'
        }]
        # ===
        response = Mock()
        response.status_code = 400
        response.text = 'Module with this Dashboard and Slug already exists'
        error = HTTPError('Error message', response=response)
        # ===
        add_module_to_dashboard_patch.side_effect = error

        response = client.post(self.upload_url, data=self.file_data)

        # see line 117 of application/controllers/upload.py
        # to see why this is expected.
        assert_that(
            self.get_from_session('upload_data')['payload'], equal_to([]))
        assert_that(response.status, equal_to('302 FOUND'))
        assert_that(
            response.headers['Location'],
            ends_with("/dashboard/{}"
                      "/cost-per-transaction/upload/success".format(
                          self.dash_id)))

        get_data_set_patch.assert_called_once_with("visas",
                                                   "cost-per-transaction")
        assert_that(create_data_set_patch.called, equal_to(False))
        get_data_group_patch.assert_called_once_with("visas")
        assert_that(create_data_group_patch.called, equal_to(False))
        assert_that(list_module_types_patch.call_count, equal_to(1))
        add_module_to_dashboard_patch.assert_called_once_with(
            'visas', {
                'type_id': 'uuid',
                'data_group': 'visas',
                'data_type': 'cost-per-transaction',
                'title': 'Cost per transaction'
            })
コード例 #18
0
    def test_redirects_if_module_exists(self, mock_get_dashboard):

        mock_get_dashboard.return_value = {
            'id': 'dashboard-uuid',
            'title': 'A dashboard',
            'description': 'All about this dashboard',
            'slug': 'valid-slug',
            'owning_organisation': 'organisation-uuid',
            'dashboard_type': 'transaction',
            'customer_type': 'Business',
            'strapline': 'Dashboard',
            'business_model': 'Department budget',
            'published': False,
            'status': 'unpublished',
            'modules': [
                {'data_type': 'user-satisfaction-score'},
                {'slug': 'slug'}
            ]
        }

        response = self.client.get(
            '/dashboard/dashboard-uuid/user-satisfaction/add',
            data=self.params())

        assert_that(response.headers['Location'],
                    ends_with('/dashboards/dashboard-uuid'))
コード例 #19
0
def test_delete_works_and_moves_user_to_setup():
    """'Delete dashboard' button works and redirects user to setup page."""
    splinter_tests.visit("#/advanced")

    do_sleep()

    button = find_delete_button()
    assert not button.first['disabled']

    # Click the delete button
    button.click()

    # Wait a moment while the deletion happens
    do_sleep()

    # Are we at the setup page now?
    assert_that(browser.url, ends_with("#/setup"))

    # If we go back to Advanced Options, is the button disabled?
    splinter_tests.visit("#/advanced")

    do_sleep()

    button = find_delete_button()
    assert button.first['disabled']
コード例 #20
0
    def test_updating_existing_dashboard(self, update_mock):
        with self.client.session_transaction() as session:
            session['oauth_token'] = {'access_token': 'token'}
            session['oauth_user'] = {
                'permissions': ['signin', 'dashboard']
            }
        data = {
            'slug': 'my-valid-slug',
            'title': 'My valid title',
            'modules-0-slug': 'carers-realtime',
            'modules-0-data_group': 'carers-allowance',
            'modules-0-data_type': 'realtime',
            'modules-0-options': '{}',
            'modules-0-query_parameters': '{}',
            'modules-0-id': 'module-uuid',
        }

        resp = self.client.post(
            '/administer-dashboards/uuid', data=data)
        post_json = update_mock.call_args[0][1]
        assert_that(post_json['modules'][0], has_entries({
            'slug': 'carers-realtime',
            'data_group': 'carers-allowance',
            'data_type': 'realtime',
            'options': {},
            'query_parameters': {},
            'id': 'module-uuid',
        }))
        assert_that(update_mock.call_args[0][0], equal_to('uuid'))
        assert_that(resp.status_code, equal_to(302))
        assert_that(
            resp.headers['Location'],
            ends_with('/administer-dashboards'))
        self.assert_flashes(
            'Updated the my-valid-slug dashboard', expected_category='success')
コード例 #21
0
    def test_failing_updating_existing_dashboard_flashes_error(
            self, update_mock):
        with self.client.session_transaction() as session:
            session['oauth_token'] = {'access_token': 'token'}
            session['oauth_user'] = {
                'permissions': ['signin', 'dashboard']
            }
        data = {
            'slug': 'my-valid-slug',
            'title': 'My valid title',
            'modules-0-slug': 'carers-realtime',
            'modules-0-data_group': 'carers-allowance',
            'modules-0-data_type': 'realtime',
            'modules-0-options': '{}',
            'modules-0-query_parameters': '{}',
            'modules-0-id': 'module-uuid',
        }
        response_json_mock = Mock()
        response_json_mock.return_value = {'message': 'Error message'}
        response = requests.Response()
        response.status_code = 400
        response.json = response_json_mock
        error = requests.HTTPError('Error message', response=response)
        update_mock.side_effect = error

        resp = self.client.post(
            '/administer-dashboards/uuid', data=data)
        assert_that(resp.status_code, equal_to(302))
        assert_that(
            resp.headers['Location'],
            ends_with('/administer-dashboards/uuid'))
        self.assert_flashes(
            'Error updating the my-valid-slug dashboard: Error message',
            expected_category='danger')
    def test_redirects_if_module_exists(self, mock_get_dashboard):

        mock_get_dashboard.return_value = {
            'id': 'dashboard-uuid',
            'title': 'A dashboard',
            'description': 'All about this dashboard',
            'slug': 'valid-slug',
            'owning_organisation': 'organisation-uuid',
            'dashboard_type': 'transaction',
            'customer_type': 'Business',
            'strapline': 'Dashboard',
            'business_model': 'Department budget',
            'published': False,
            'status': 'unpublished',
            'modules': [{
                'data_type': 'user-satisfaction-score'
            }, {
                'slug': 'slug'
            }]
        }

        response = self.client.get(
            '/dashboard/dashboard-uuid/user-satisfaction/add',
            data=self.params())

        assert_that(response.headers['Location'],
                    ends_with('/dashboards/dashboard-uuid'))
コード例 #23
0
    def test_http_error_from_backdrop_flashes_message(
            self,
            data_set_post_patch,
            is_virus_patch,
            get_data_set_patch,
            client):
        is_virus_patch.return_value = False
        get_data_set_patch.return_value = {
            'data_group': 'carers-allowance',
            'data_type': 'volumetrics',
            'bearer_token': 'abc123', 'foo': 'bar'
        }

        data_set_post_patch.side_effect = backdrop_response(401, {})
        post_data = {
            'file':
                (StringIO('_timestamp,foo\n2014-08-05T00:00:00Z,40'),
                    'MYSPECIALFILE.csv')
        }
        response = client.post(
            '/upload-data/carers-allowance/volumetrics',
            data=post_data)

        assert_that(
            self.get_from_session('upload_data')['payload'],
            equal_to(['[401] {}']))
        assert_that(response.headers['Location'], ends_with('/upload-data'))
        assert_that(response.status_code, equal_to(302))
コード例 #24
0
    def test_user_can_post_to_upload_data(self, data_set_post_patch,
                                          is_virus_patch, get_data_set_patch,
                                          client):
        is_virus_patch.return_value = False
        get_data_set_patch.return_value = {
            'data_group': 'carers-allowance',
            'data_type': 'volumetrics',
            'bearer_token': 'abc123',
            'foo': 'bar'
        }

        post_data = {
            'file': (StringIO('_timestamp,foo\n2014-08-05T00:00:00Z,40'),
                     'MYSPECIALFILE.csv')
        }
        response = client.post('/upload-data/carers-allowance/volumetrics',
                               data=post_data)

        expected_post = [{u'_timestamp': u'2014-08-05T00:00:00Z', u'foo': 40}]
        data_set_post_patch.assert_called_once_with(expected_post)

        upload_done_path = '/upload-data'
        assert_that(response.headers['Location'], ends_with(upload_done_path))
        assert_that(response.status_code, equal_to(302))

        assert_that(
            self.get_from_session('upload_data'),
            has_entries({
                u'data_type': u'volumetrics',
                u'data_group': u'carers-allowance'
            }))
コード例 #25
0
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)))
コード例 #26
0
 def test_redirects_to_channel_options_page(self, mock_get_dashboard):
     response = self.client.post(
         '/dashboard/dashboard-uuid/digital-take-up/upload-options',
         data=self.params())
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/channel-options'))
コード例 #27
0
    def test_user_can_post_to_upload_data(
            self,
            data_set_post_patch,
            is_virus_patch,
            get_data_set_patch,
            client):
        is_virus_patch.return_value = False
        get_data_set_patch.return_value = {
            'data_group': 'carers-allowance',
            'data_type': 'volumetrics',
            'bearer_token': 'abc123', 'foo': 'bar'
        }

        post_data = {
            'file':
                (StringIO('_timestamp,foo\n2014-08-05T00:00:00Z,40'),
                    'MYSPECIALFILE.csv')
        }
        response = client.post(
            '/upload-data/carers-allowance/volumetrics',
            data=post_data)

        expected_post = [{u'_timestamp': u'2014-08-05T00:00:00Z', u'foo': 40}]
        data_set_post_patch.assert_called_once_with(expected_post)

        upload_done_path = '/upload-data'
        assert_that(response.headers['Location'], ends_with(upload_done_path))
        assert_that(response.status_code, equal_to(302))

        assert_that(
            self.get_from_session('upload_data'),
            has_entries({
                u'data_type': u'volumetrics',
                u'data_group': u'carers-allowance'
            }))
コード例 #28
0
ファイル: client.py プロジェクト: wazo-platform/wazo-confd
 def assert_content_disposition(self, filename):
     headers = {
         key.lower(): value
         for key, value in self.response.headers.items()
     }
     expected = has_entry('content-disposition',
                          ends_with('filename={}'.format(filename)))
     assert_that(headers, expected, 'Content-Disposition header not found')
コード例 #29
0
 def test_signout_redirects_properly_and_clears_session(
         self, oauth_authorization_url_patch, oauth_get_patch,
         oauth_fetch_token_patch, client):
     response = client.get("/sign-out")
     assert_that(response.status_code, equal_to(302))
     assert_that(response.headers['Location'], ends_with('/users/sign_out'))
     with client.session_transaction() as session:
         assert_that(session, equal_to({}))
コード例 #30
0
 def test_published_dashboards_cannot_be_edited(
         self, mock_get_dashboard):
     response = self.client.get('/dashboards/dashboard-uuid')
     self.assert_flashes(
         'In review or published dashboards cannot be edited', 'info')
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/dashboards'))
 def test_renders_a_contact_us_page_if_unable_to_extract_done_page(
         self, mock_get_dashboard):
     params = self.params(
         {'done_page_url': 'http://www.gov.uk/some-transaction'})
     response = self.client.post(
         '/dashboard/dashboard-uuid/user-satisfaction/add', data=params)
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'], ends_with('/get-in-touch'))
コード例 #32
0
ファイル: test_heart_beat.py プロジェクト: optionalg/storops
 def test_ping_sp_cmd(self):
     hb = NodeHeartBeat(interval=20)
     ip = '1.1.1.1'
     hb.add('spa', ip)
     hb.update_by_ip(ip, latency=5.123)
     assert_that(' '.join(hb.get_agent(ip)),
                 ends_with('-h 1.1.1.1 -t 35 -np getagent'))
     hb.stop()
コード例 #33
0
ファイル: test_heart_beat.py プロジェクト: crook/storops
 def test_ping_sp_cmd(self):
     hb = NodeHeartBeat(interval=20)
     ip = '1.1.1.1'
     hb.add('spa', ip)
     hb.update_by_ip(ip, latency=5.123)
     assert_that(' '.join(hb.get_agent(ip)),
                 ends_with('-h 1.1.1.1 -t 35 -np getagent'))
     hb.stop()
コード例 #34
0
def clean_slate():
    # Delete all the dashboards
    delete_all_dashboards("test_user", "e2e_password", "login.etherios.com")
    # Log back in
    log_in_clean("test_user", "e2e_password", "login.etherios.com")

    # With no dashboards, logging in should lead to the dashboard setup page.
    assert_that(browser.url, ends_with("#/setup"))
コード例 #35
0
def LanguageServerCompleter_Diagnostics_PercentEncodeCannonical_test( app ):
  completer = MockCompleter()
  filepath = os.path.realpath( '/foo?' )
  uri = lsp.FilePathToUri( filepath )
  assert_that( uri, ends_with( '%3F' ) )
  request_data = RequestWrap( BuildRequest( line_num = 1,
                                            column_num = 1,
                                            filepath = filepath,
                                            contents = '' ) )
  notification = {
    'jsonrpc': '2.0',
    'method': 'textDocument/publishDiagnostics',
    'params': {
      'uri': uri.replace( '%3F', '%3f' ),
      'diagnostics': [ {
        'range': {
          'start': { 'line': 3, 'character': 10 },
          'end': { 'line': 3, 'character': 11 }
        },
        'severity': 1,
        'message': 'First error'
      } ]
    }
  }
  completer.GetConnection()._notifications.put( notification )
  completer.HandleNotificationInPollThread( notification )

  with patch.object( completer, '_ServerIsInitialized', return_value = True ):
    completer.OnFileReadyToParse( request_data )
    # Simulate receipt of response and initialization complete
    initialize_response = {
      'result': {
        'capabilities': {}
      }
    }
    completer._HandleInitializeInPollThread( initialize_response )

    diagnostics = contains_exactly(
      has_entries( {
        'kind': equal_to( 'ERROR' ),
        'location': LocationMatcher( filepath, 4, 11 ),
        'location_extent': RangeMatcher( filepath, ( 4, 11 ), ( 4, 12 ) ),
        'ranges': contains_exactly(
           RangeMatcher( filepath, ( 4, 11 ), ( 4, 12 ) ) ),
        'text': equal_to( 'First error' ),
        'fixit_available': False
      } )
    )

    assert_that( completer.OnFileReadyToParse( request_data ), diagnostics )

    assert_that(
      completer.PollForMessages( request_data ),
      contains_exactly( has_entries( {
        'diagnostics': diagnostics,
        'filepath': filepath
      } ) )
    )
 def test_renders_a_contact_us_page_if_no_user_satisfaction_data_set(
         self, mock_list_module_types, mock_get_data_set,
         mock_get_dashboard):
     mock_get_data_set.return_value = None
     response = self.client.post(
         '/dashboard/dashboard-uuid/user-satisfaction/add',
         data=self.params())
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'], ends_with('/get-in-touch'))
コード例 #37
0
ファイル: test_fs.py プロジェクト: Iconoclasteinc/tgit
def test_removes_files_from_folder_if_they_match_given_condition(tmpdir):
    for filename in "track1.mp3", "track2.flac", "track3.mp3":
        touch(tmpdir.join(filename).strpath)

    fs.remove_files(folder=tmpdir.strpath, matching=lambda entry: entry.endswith(".mp3"))
    assert_that(fs.list_dir(tmpdir.strpath), contains(ends_with("track2.flac")), "files left after removing mp3 files")

    fs.remove_files(folder=tmpdir.strpath)
    assert_that(fs.list_dir(tmpdir.strpath), empty(), "files left after removing remaining files")
コード例 #38
0
 def test_redirects_to_about_your_service_page(
         self,
         mock_update_dashboard,
         mock_get_dashboard):
     response = self.client.post(
         '/dashboards/dashboard-uuid/publish', data={})
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/dashboards'))
コード例 #39
0
 def test_api_choice_redirects_to_api_get_in_touch_page(
         self, mock_get_dashboard):
     data = self.params({'upload_option': 'api'})
     response = self.client.post(
         '/dashboard/dashboard-uuid/digital-take-up/upload-options',
         data=data)
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/api-get-in-touch'))
コード例 #40
0
 def test_redirects_to_about_your_service_page(self, mock_ses_connection,
                                               mock_update_dashboard,
                                               mock_get_dashboard):
     response = self.client.post(
         '/dashboards/dashboard-uuid/send-for-review', data={})
     self.assert_flashes('Your dashboard has been sent for review',
                         'success')
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'], ends_with('/dashboards'))
コード例 #41
0
 def test_api_choice_redirects_to_api_get_in_touch_page(
         self, mock_get_dashboard):
     data = self.params({'upload_option': 'api'})
     response = self.client.post(
         '/dashboard/dashboard-uuid/digital-take-up/upload-options',
         data=data)
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/api-get-in-touch'))
コード例 #42
0
    def fn():
        # Attempt to go to the given page
        splinter_tests.visit(visited_uri)

        # Sleep the test runner for a moment, to allow the browser to catch up.
        splinter_tests.utils.do_sleep()

        # Check that we ended up on the login page
        assert_that(splinter_tests.browser.url, ends_with("/#/login"))
コード例 #43
0
    def fn():
        # Attempt to go to the given page
        splinter_tests.visit(visited_uri)

        # Sleep the test runner for a moment, to allow the browser to catch up.
        splinter_tests.utils.do_sleep()

        # Check that we ended up on the login page
        assert_that(splinter_tests.browser.url, ends_with("/#/login"))
コード例 #44
0
def test_page_contents():
    """The setup page should appear correctly."""
    assert_that(browser.url, ends_with("#/setup"))

    assert_that(browser.title, starts_with("Dashboard Creation |"))

    header = browser.find_by_css("body > .content-holder > .container > h1")
    assert_that(header.first.text, is_("Dashboard Creation"))

    assert browser.is_text_present(STEP_TITLES[1])
コード例 #45
0
 def test_renders_a_contact_us_page_if_unable_to_extract_done_page(
         self, mock_get_dashboard):
     params = self.params({
         'done_page_url': 'http://www.gov.uk/some-transaction'})
     response = self.client.post(
         '/dashboard/dashboard-uuid/user-satisfaction/add',
         data=params)
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/get-in-touch'))
コード例 #46
0
 def test_GIVEN_variables_from_different_files_WHEN_calculate_THEN_history_added(self):
     self._make_two_gridded()
     expr = 'var1 + var2'
     res = self.calc.evaluate(self.data, expr)
     expected_history = "Evaluated using CIS version " + __version__ + \
                        "\nExpression evaluated: 'var1 + var2'" + \
                        "\nwith variables: 'var1' from files ['filename1']," + \
                        "\n'var2' from files ['filename2']."
     # Do an ends_with comparison because history starts with timestamp
     assert_that(res.history, ends_with(expected_history))
コード例 #47
0
def setup():
    splinter_tests.start_browser()

    # First, logout to ensure that we are in fact logged out.
    splinter_tests.visit("/logout")

    # Wait a few seconds for redirect.
    splinter_tests.utils.do_sleep()

    assert_that(splinter_tests.browser.url, ends_with("/#/login"))
コード例 #48
0
def setup():
    splinter_tests.start_browser()

    # First, logout to ensure that we are in fact logged out.
    splinter_tests.visit("/logout")

    # Wait a few seconds for redirect.
    splinter_tests.utils.do_sleep()

    assert_that(splinter_tests.browser.url, ends_with("/#/login"))
コード例 #49
0
def test_page_contents():
    """The setup page should appear correctly."""
    assert_that(browser.url, ends_with("#/setup"))

    assert_that(browser.title, starts_with("Dashboard Creation |"))

    header = browser.find_by_css("body > .content-holder > .container > h1")
    assert_that(header.first.text, is_("Dashboard Creation"))

    assert browser.is_text_present(STEP_TITLES[1])
コード例 #50
0
ファイル: test_loc.py プロジェクト: ipgur/pipeline
    def verify_results(self, loc):
        """Testing for expected results."""
        results = sorted(loc.results, key=lambda entry: Adapter(entry).file)
        assert_that(len(results), equal_to(len(self.expected_results())))

        for idx, expected in enumerate(self.expected_results()):
            assert_that(Adapter(results[idx]).file, ends_with(expected.filename))
            assert_that(Adapter(results[idx]).loc, equal_to(expected.loc))
            assert_that(Adapter(results[idx]).com, equal_to(expected.com))
            assert_that(float(Adapter(results[idx]).ratio), equal_to(expected.ratio))
コード例 #51
0
def click_add_widget():
    '''Find and click the "Add Widget" button, if it is present.'''
    # Find the 'Add Widget' button
    btn = browser.find_by_xpath("//button[contains(.,'Add Widget')]")
    assert not btn.is_empty()

    # Click the button, make sure we landed at the Add Widget page
    btn.first.click()
    assert_that(browser.url, ends_with("/#/add_widget"))
    assert browser.is_text_present("Create a new Widget")
コード例 #52
0
def test_switch_to_eu_then_back():
    """
    When the user clicks 'Europe Cloud', they end up on the page that
    will have them log in against the EU Cloud. Then, if they click on 'US
    Cloud', they end up back on #/login
    """
    browser = splinter_tests.browser
    assert_that(browser.url, ends_with("#/login"))

    browser.find_link_by_text("Europe Cloud").click()

    assert_that(browser.url, ends_with("#/login/login.etherios.co.uk"))

    browser.find_link_by_text("US Cloud").click()

    assert_that(browser.url, ends_with("#/login"))

    # Check that the grayed-out text indicating the login server URL is not
    # present.
    assert browser.is_element_not_present_by_css("h1.title > span.text-muted")
コード例 #53
0
    def test_handles_invalid_spreadsheet(
            self,
            add_module_to_dashboard_patch,
            list_module_types_patch,
            create_data_group_patch,
            get_data_group_patch,
            get_module_config_patch,
            create_data_set_patch,
            get_data_set_patch,
            get_dashboard_patch,
            client):

        get_module_config_patch.return_value = {
            'title': 'Cost per transaction'}

        get_dashboard_patch.return_value = {
            'slug': 'visas'}

        get_data_set_patch.return_value = {
            'name': 'apply_uk_visa_transactions_by_channel',
            'data_type': 'transactions-by-channel',
            'data_group': 'apply-uk-visa',
            'bearer_token': 'abc123',
            'upload_format': 'csv',
            'auto_ids': '_timestamp, period, channel',
            'max_age_expected': 1300000
        }
        get_data_group_patch.return_value = {
            'name': 'visas'
        }
        list_module_types_patch.return_value = [{'name': 'single_timeseries',
                                                 'id': 'uuid'}]
        add_module_to_dashboard_patch.return_value = {}

        self.upload_spreadsheet_mock.return_value = \
            (['Message 1', 'Message 2'], False)

        response = client.post(self.upload_url, data=self.file_data)

        # see line 117 of application/controllers/upload.py
        # to see why this is expected.
        assert_that(
            self.get_from_session('upload_data')['payload'],
            equal_to(['Message 1', 'Message 2']))
        assert_that(response.status, equal_to('302 FOUND'))
        assert_that(
            response.headers['Location'],
            ends_with("/dashboard/{}"
                      "/cost-per-transaction/upload".format(
                          self.dash_id)))
        with client.session_transaction() as session:
            assert_that(
                '_flashes' in session,
                equal_to(False))
コード例 #54
0
ファイル: test_calc.py プロジェクト: cedadev/cis
 def test_GIVEN_variables_from_same_file_WHEN_calculate_THEN_history_added(self):
     self._make_two_ungridded_data()
     self.data[1].alias = 'alias2'
     self.data[1].filenames = self.data[0].filenames
     expr = 'var1 + alias2'
     res = self.calc.evaluate(self.data, expr)
     expected_history = "Evaluated using CIS version " + __version__ + \
                        "\nExpression evaluated: 'var1 + alias2'" + \
                        "\nwith variables: 'var1' from files ['filename1']," + \
                        "\n'var2' (as 'alias2') from files ['filename1']."
     # Do an ends_with comparison because history starts with timestamp
     assert_that(res.history, ends_with(expected_history))
コード例 #55
0
def has_test_case(name, *matchers):
    return has_property('test_cases',
                        has_item(
                            all_of(
                                any_of(
                                    has_entry('fullName', ends_with(name)),
                                    has_entry('name', starts_with(name))
                                ),
                                *matchers
                            )
                        )
                        )
コード例 #56
0
 def test_redirects_to_about_your_service_page(
         self,
         mock_ses_connection,
         mock_update_dashboard,
         mock_get_dashboard):
     response = self.client.post(
         '/dashboards/dashboard-uuid/send-for-review', data={})
     self.assert_flashes(
         'Your dashboard has been sent for review', 'success')
     assert_that(response.status, equal_to('302 FOUND'))
     assert_that(response.headers['Location'],
                 ends_with('/dashboards'))