def test_base_class(self):
        headers = {
            'X-Error-Title': 'Storage service down',
            'X-Error-Description': ('The configured storage service is not '
                                    'responding to requests. Please contact '
                                    'your service provider'),
            'X-Error-Status': falcon.HTTP_503
        }

        expected_body = [
            b'{\n'
            b'    "title": "Storage service down",\n'
            b'    "description": "The configured storage service is not '
            b'responding to requests. Please contact your service provider",\n'
            b'    "code": 10042\n'
            b'}'
        ]

        # Try it with Accept: */*
        headers['Accept'] = '*/*'
        body = self.simulate_request('/fail', headers=headers)
        self.assertEqual(self.srmock.status, headers['X-Error-Status'])
        self.assertThat(lambda: json.loads(body[0]), Not(raises(ValueError)))
        self.assertEqual(expected_body, body)

        # Now try it with application/json
        headers['Accept'] = 'application/json'
        body = self.simulate_request('/fail', headers=headers)
        self.assertEqual(self.srmock.status, headers['X-Error-Status'])
        self.assertThat(lambda: json.loads(body[0]), Not(raises(ValueError)))
        self.assertEqual(body, expected_body)

    def test_base_class(self):
        headers = {
            'X-Error-Title': 'Storage service down',
            'X-Error-Description': ('The configured storage service is not '
                                    'responding to requests. Please contact '
                                    'your service provider.'),
            'X-Error-Status': falcon.HTTP_503
        }

        expected_body = {
            'title': 'Storage service down',
            'description': ('The configured storage service is not '
                            'responding to requests. Please contact '
                            'your service provider.'),
            'code': 10042,
        }

        # Try it with Accept: */*
        headers['Accept'] = '*/*'
        body = self.simulate_request('/fail', headers=headers, decode='utf-8')

        self.assertEqual(self.srmock.status, headers['X-Error-Status'])
        self.assertThat(lambda: json.loads(body), Not(raises(ValueError)))
        self.assertEqual(expected_body, json.loads(body))

        # Now try it with application/json
        headers['Accept'] = 'application/json'
        body = self.simulate_request('/fail', headers=headers, decode='utf-8')

        self.assertEqual(self.srmock.status, headers['X-Error-Status'])
        self.assertThat(lambda: json.loads(body), Not(raises(ValueError)))
        self.assertEqual(json.loads(body), expected_body)

 def test_find_invalid_usage(self):
     """
     Passing fewer or more than one query raises `ValueError`.
     """
     enum = Enum('doc', [])
     self.assertThat(enum.find, raises(ValueError))
     self.assertThat(
         lambda: enum.find(foo=u'a', bar=u'b'),
         raises(ValueError))

 def test_must_specify_tags_with_tags_options(self):
     fn = lambda: safe_parse_arguments(['--fail', 'foo', '--tag'])
     self.assertThat(
         fn,
         MatchesAny(
             raises(RuntimeError('--tag option requires 1 argument')),
             raises(RuntimeError('--tag option requires an argument')),
         )
     )

 def test_provision_at_cap(self):
     source = model.Source(None, None)
     c = cache.Cache("foo", memory.Store({}), source, maximum=2)
     c.provision(2)
     self.assertThat(lambda: c.provision(1), raises(ValueError))
     # The source was not interrogated for more resources.
     self.assertEqual(['2'], source.provision(1))
     with read_locked(c.store):
         self.assertEqual('0,1', c.store['pool/foo'])
         self.assertThat(lambda:c.store['resource/2'], raises(KeyError))

 def test_TestCommand_get_run_command_outside_setUp_fails(self):
     self.dirty()
     ui = UI()
     ui.here = self.tempdir
     command = TestCommand(ui, None)
     self.set_config('[DEFAULT]\ntest_command=foo\n')
     self.assertThat(command.get_run_command, raises(TypeError))
     command.setUp()
     command.cleanUp()
     self.assertThat(command.get_run_command, raises(TypeError))

 def test_delete(self):
     s = self.make_store()
     s2 = self.make_store()
     with write_locked(s):
         s['foo'] = 'bar'
     with write_locked(s):
         del s['foo']
     with read_locked(s):
         self.assertThat(lambda:s['foo'], raises(KeyError))
     # The change is immediately visible to other store instances.
     with read_locked(s2):
         self.assertThat(lambda:s2['foo'], raises(KeyError))

 def test_discard_force_ignores_reserve(self):
     source = model.Source(None, None)
     c = cache.Cache("foo", memory.Store({}), source, reserve=1)
     c.discard(c.provision(2), force=True)
     self.assertThat(source._calls, MatchesAny(
         Equals([('provision', 2), ('discard', ['0', '1'])]),
         Equals([('provision', 2), ('discard', ['1', '0'])])))
     # The instance should have been unmapped in both directions from the
     # store.
     with read_locked(c.store):
         self.assertEqual('', c.store['pool/foo'])
         self.assertThat(lambda:c.store['resource/0'], raises(KeyError))
         self.assertThat(lambda:c.store['resource/1'], raises(KeyError))

 def test_header_types(self):
     """
     Header keys and values must be bytes, not unicode.
     """
     self.assertThat(
         lambda: Request(method='get', url='http://google.com/',
                         headers={u'foo': b'bar'}),
         raises(TypeError("headers key {0!r} is not bytes".format(u'foo')))
         )
     self.assertThat(
         lambda: Request(method='get', url='http://google.com/',
                         headers={b'foo': u'bar'}),
         raises(TypeError("headers value {0!r} is not bytes".format(u'bar')))
         )

    def test_not_set_delta_property_correctly(self):
        self.assertThat(
            lambda: deltas.BaseDeltasGenerator(
                source_path=self.source_file, target_path=self.target_file,
                delta_format=None, delta_tool_path=self.delta_tool_path),
            m.raises(deltas.errors.DeltaFormatError)
        )
        exception = self.assertRaises(deltas.errors.DeltaFormatError,
                                      deltas.BaseDeltasGenerator,
                                      source_path=self.source_file,
                                      target_path=self.target_file,
                                      delta_format=None,
                                      delta_tool_path='/usr/bin/xdelta3')
        expected = 'delta_format must be set in subclass!'
        self.assertEqual(str(exception), expected)

        self.assertThat(
            lambda: deltas.BaseDeltasGenerator(
                source_path=self.source_file, target_path=self.target_file,
                delta_format='xdelta3',
                delta_tool_path=None),
            m.raises(deltas.errors.DeltaToolError)
        )
        exception = self.assertRaises(deltas.errors.DeltaToolError,
                                      deltas.BaseDeltasGenerator,
                                      source_path=self.source_file,
                                      target_path=self.target_file,
                                      delta_format='xdelta3',
                                      delta_tool_path=None)
        expected = 'delta_tool_path must be set in subclass!'
        self.assertEqual(str(exception), expected)

        self.assertThat(
            lambda: deltas.BaseDeltasGenerator(
                source_path=self.source_file,
                target_path=self.target_file,
                delta_format='not-defined',
                delta_tool_path='/usr/bin/xdelta3'),
            m.raises(deltas.errors.DeltaFormatOptionError)
        )
        exception = self.assertRaises(deltas.errors.DeltaFormatOptionError,
                                      deltas.BaseDeltasGenerator,
                                      source_path=self.source_file,
                                      target_path=self.target_file,
                                      delta_format='invalid-delta-format',
                                      delta_tool_path=self.delta_tool_path)
        expected = """delta_format must be a option in ['xdelta3'].
for now delta_format='invalid-delta-format'"""
        self.assertEqual(str(exception), expected)

 def test_discard_multiple(self):
     source = model.Source(None, None)
     c = cache.Cache("foo", memory.Store({}), source)
     c.provision(4)
     c.discard(['foo-0', 'foo-2'])
     self.assertEqual(2, c.in_use())
     self.assertEqual(0, c.cached())
     self.assertEqual(
         [('provision', 4), ('discard', ['0', '2'])], source._calls)
     # The instances should have been unmapped in both directions from the
     # store.
     with read_locked(c.store):
         self.assertEqual('1,3', c.store['pool/foo'])
         self.assertThat(lambda:c.store['resource/0'], raises(KeyError))
         self.assertThat(lambda:c.store['resource/2'], raises(KeyError))

    def test_duplicateHandlers(self):
        """
        Only one handler for an accept type may be specified.
        """
        @implementer(INegotiableResource)
        class _BarJSON(object):
            contentType = b'application/json'
            acceptTypes = [b'application/json']

        self.assertThat(
            partial(ContentTypeNegotiator, [_FooJSON(), _FooJSON()]),
            raises(ValueError))
        self.assertThat(
            partial(ContentTypeNegotiator, [_FooJSON(), _BarJSON()]),
            raises(ValueError))

 def test_rejects_doubledash(self):
     base = self.useFixture(TempDir()).path
     arg = path.ExistingPathArgument('path')
     self.addCleanup(os.chdir, os.getcwd())
     os.chdir(base)
     with open('--', 'wt') as f:pass
     self.assertThat(lambda: arg.parse(['--']), raises(ValueError))

 def test_format_version_4(self):
     """A hypothetical summary format version 4 is rejected"""
     self.make_bug_summary("1", format_version=4)
     tracker = self.get_tracker()
     self.assertThat(lambda: tracker.getRemoteStatus("1"),
         raises(SummaryVersionError))
     tracker.getRemoteImportance("1")

 def test_none(self):
     """
     Cannot create a task name for ``None``.
     """
     self.assertThat(
         lambda: task_name(None),
         raises(ValueError))

 def test_duplicate_values(self):
     """
     Constructing an enumeration with duplicate values results in
     `ValueError` being raised.
     """
     values = [
         EnumItem(u'foo', u'Foo'),
         EnumItem(u'bar', u'Bar'),
         EnumItem(u'foo', u'Not Foo', quux=u'frob')]
     self.assertThat(
         lambda: Enum('doc', values),
         raises(ValueError))
     pairs = [(e.value, e.desc) for e in values]
     self.assertThat(
         lambda: Enum.from_pairs('doc', pairs),
         raises(ValueError))

    def test_epic_fail_xml(self):
        headers = {
            'Accept': 'text/xml'
        }

        expected_body = ('<?xml version="1.0" encoding="UTF-8"?>' +
                         '<error>' +
                         '<title>Internet crashed</title>' +
                         '<description>' +
                         'Catastrophic weather event due to climate change.' +
                         '</description>' +
                         '<code>8733224</code>' +
                         '<link>' +
                         '<text>Drill baby drill!</text>' +
                         '<href>http://example.com/api/climate</href>' +
                         '<rel>help</rel>' +
                         '</link>' +
                         '</error>')

        body = self.simulate_request('/fail', headers=headers, method='PUT',
                                     decode='utf-8')

        self.assertEqual(self.srmock.status, falcon.HTTP_792)
        self.assertThat(lambda: et.fromstring(body), Not(raises(ValueError)))
        self.assertEqual(body, expected_body)

 def test_format_version_1(self):
     """Initial format without version marker is rejected"""
     self.make_bug_summary("1", format_version=1)
     tracker = self.get_tracker()
     self.assertThat(lambda: tracker.getRemoteStatus("1"),
         raises(SummaryParseError))
     tracker.getRemoteImportance("1")

 def test_maximum_exceeded(self):
     if not self.test_maximum:
         self.skip("Cannot test maximum.")
     source = self.make_source()
     self.assertThat(lambda: source.provision(self.test_maximum + 1),
         raises(TooManyInstances))
     source.discard(source.provision(self.test_maximum))

    def test_greeting_mouse(self):
        """Greeting with mouse navigation"""

        entry_name = self.app.select_single(BuilderName='entry_name')
        entry_color = self.app.select_single(BuilderName='entry_color')

        # FIXME: This isn't necessary for real X, but under Xvfb there is no
        # default focus sometimes
        if not entry_name.has_focus:
            self.mouse.click_object(entry_name)

        # type in name and color
        self.keyboard.type('Joe')
        self.mouse.click_object(entry_color)
        self.keyboard.type('blue')

        # entries should now have the typed text
        self.assertThat(entry_name.text, Eventually(Equals('Joe')))
        self.assertThat(entry_color.text, Eventually(Equals('blue')))

        # should not have any dialogs
        self.assertThat(
            lambda: self.app.select_single('GtkMessageDialog'),
            raises(StateNotFoundError)
        )

        # focus and activate the "Greet" button
        btn = self.app.select_single('GtkButton', label='Greet')
        self.assertNotEqual(btn, None)
        self.mouse.click_object(btn)

        # should get the greeting dialog
        md = self.app.wait_select_single('GtkMessageDialog', visible=True)

        # we expect the message dialog to show the corresponding greeting
        self.assertNotEqual(md.select_single('GtkLabel',
                                             label=u'Hello Joe, you like blue.'),
                            None)

        # close the dialog
        btn = md.select_single('GtkButton')
        self.mouse.click_object(btn)
        self.assertThat(
            lambda: self.app.select_single('GtkMessageDialog', visible=True),
            raises(StateNotFoundError)
        )