async def test_ws_connect_deflate_per_message(loop, ws_key, key_data) -> None:
    resp = mock.Mock()
    resp.status = 101
    resp.headers = {
        hdrs.UPGRADE: hdrs.WEBSOCKET,
        hdrs.CONNECTION: hdrs.UPGRADE,
        hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
        hdrs.SEC_WEBSOCKET_EXTENSIONS: 'permessage-deflate',
    }
    with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
        with mock.patch('aiohttp.client.os') as m_os:
            with mock.patch('aiohttp.client.ClientSession.request') as m_req:
                m_os.urandom.return_value = key_data
                m_req.return_value = loop.create_future()
                m_req.return_value.set_result(resp)
                writer = WebSocketWriter.return_value = mock.Mock()
                send = writer.send = make_mocked_coro()

                session = aiohttp.ClientSession(loop=loop)
                resp = await session.ws_connect('http://test.org')

                await resp.send_str('string', compress=-1)
                send.assert_called_with('string', binary=False, compress=-1)

                await resp.send_bytes(b'bytes', compress=15)
                send.assert_called_with(b'bytes', binary=True, compress=15)

                await resp.send_json([{}], compress=-9)
                send.assert_called_with('[{}]', binary=False, compress=-9)

                await session.close()

 def setUp(self):
     self.patcher1 = patch("samireland.views.EditableText.objects.create")
     self.patcher2 = patch("samireland.views.EditableText.objects.get")
     self.mock_create = self.patcher1.start()
     self.mock_get = self.patcher2.start()
     self.mock_create.return_value = "EDTEXT"
     self.mock_get.side_effect = EditableText.DoesNotExist

 def test_entry_existence(self, capsys):
     """
     Test recognition of already inserted entries.
     """
     apath = os.path.abspath(os.getcwd())
     sqlpath = os.path.join(apath, "bbarchivist.db")
     with mock.patch('bbarchivist.iniconfig.config_homepath', mock.MagicMock(return_value=apath)):
         try:
             cnxn = sqlite3.connect(sqlpath)
             with cnxn:
                 crsr = cnxn.cursor()
                 crsr.execute("DROP TABLE IF EXISTS Swrelease")
                 reqid = "INTEGER PRIMARY KEY"
                 reqs = "TEXT NOT NULL UNIQUE COLLATE NOCASE"
                 reqs2 = "TEXT"
                 table = "Swrelease(Id {0}, Os {1}, Software {1}, Available {2}, Date {2})".format(
                     *(reqid, reqs, reqs2))
                 crsr.execute("CREATE TABLE IF NOT EXISTS " + table)
         except sqlite3.Error:
             assert False
         assert not bs.check_exists("70.OSVERSION", "80.SWVERSION")
         bs.insert("70.OSVERSION", "80.SWVERSION", "available")
         assert bs.check_exists("70.OSVERSION", "80.SWVERSION")
         with mock.patch("sqlite3.connect", mock.MagicMock(side_effect=sqlite3.Error)):
             bs.check_exists("70.OSVERSION", "80.SWVERSION")
             assert "\n" in capsys.readouterr()[0]

    def test_midnight_turnover_after_midnight_inside_period(self):
        """Test midnight turnover setting before midnight inside period ."""
        test_time = self.hass.config.time_zone.localize(
            datetime(2019, 1, 10, 21, 0, 0)).astimezone(pytz.UTC)
        config = {
            'binary_sensor': [
                {
                    'platform': 'tod',
                    'name': 'Night',
                    'after': '22:00',
                    'before': '5:00'
                },
            ]
        }
        with patch('homeassistant.components.tod.binary_sensor.dt_util.utcnow',
                   return_value=test_time):
            setup_component(self.hass, 'binary_sensor', config)

            state = self.hass.states.get('binary_sensor.night')
            assert state.state == STATE_OFF

            self.hass.block_till_done()

        with patch('homeassistant.components.tod.binary_sensor.dt_util.utcnow',
                   return_value=test_time + timedelta(hours=1)):

            self.hass.bus.fire(ha.EVENT_TIME_CHANGED, {
                ha.ATTR_NOW: test_time + timedelta(hours=1)})

            self.hass.block_till_done()
            state = self.hass.states.get('binary_sensor.night')
            assert state.state == STATE_ON

 def test_blacklist(self):
     with patch('recommendation.mozlog.middleware.current_app') as app:
         mock_request = self._request(path=LOG_PATH_BLACKLIST[0])
         mock_response = self._response()
         with patch(REQUEST_PATH, mock_request):
             request_summary(mock_response)
         eq_(app.logger.info.call_count, 0)

def test_zwave_ready_wait(hass, mock_openzwave):
    """Test that zwave continues after waiting for network ready."""
    # Initialize zwave
    yield from async_setup_component(hass, 'zwave', {'zwave': {}})
    yield from hass.async_block_till_done()

    sleeps = []

    def utcnow():
        return datetime.fromtimestamp(len(sleeps))

    asyncio_sleep = asyncio.sleep

    @asyncio.coroutine
    def sleep(duration, loop=None):
        if duration > 0:
            sleeps.append(duration)
        yield from asyncio_sleep(0)

    with patch('homeassistant.components.zwave.dt_util.utcnow', new=utcnow):
        with patch('asyncio.sleep', new=sleep):
            with patch.object(zwave, '_LOGGER') as mock_logger:
                hass.data[DATA_NETWORK].state = MockNetwork.STATE_STARTED
                hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
                yield from hass.async_block_till_done()

                assert len(sleeps) == const.NETWORK_READY_WAIT_SECS
                assert mock_logger.warning.called
                assert len(mock_logger.warning.mock_calls) == 1
                assert mock_logger.warning.mock_calls[0][1][1] == \
                    const.NETWORK_READY_WAIT_SECS

def test_saving_and_loading(hass):
    """Test that we're saving and loading correctly."""
    class TestFlow(data_entry_flow.FlowHandler):
        VERSION = 5

        @asyncio.coroutine
        def async_step_init(self, user_input=None):
            return self.async_create_entry(
                title='Test Title',
                data={
                    'token': 'abcd'
                }
            )

    with patch.dict(config_entries.HANDLERS, {'test': TestFlow}):
        yield from hass.config_entries.flow.async_init('test')

    class Test2Flow(data_entry_flow.FlowHandler):
        VERSION = 3

        @asyncio.coroutine
        def async_step_init(self, user_input=None):
            return self.async_create_entry(
                title='Test 2 Title',
                data={
                    'username': 'bla'
                }
            )

    json_path = 'homeassistant.util.json.open'

    with patch('homeassistant.config_entries.HANDLERS.get',
               return_value=Test2Flow), \
            patch.object(config_entries, 'SAVE_DELAY', 0):
        yield from hass.config_entries.flow.async_init('test')

    with patch(json_path, mock_open(), create=True) as mock_write:
        # To trigger the call_later
        yield from asyncio.sleep(0, loop=hass.loop)
        # To execute the save
        yield from hass.async_block_till_done()

    # Mock open calls are: open file, context enter, write, context leave
    written = mock_write.mock_calls[2][1][0]

    # Now load written data in new config manager
    manager = config_entries.ConfigEntries(hass, {})

    with patch('os.path.isfile', return_value=True), \
            patch(json_path, mock_open(read_data=written), create=True):
        yield from manager.async_load()

    # Ensure same order
    for orig, loaded in zip(hass.config_entries.async_entries(),
                            manager.async_entries()):
        assert orig.version == loaded.version
        assert orig.domain == loaded.domain
        assert orig.title == loaded.title
        assert orig.data == loaded.data
        assert orig.source == loaded.source

    def setUp(self):
        super().setUp()

        class props:
            rosdistro = 'indigo'
            catkin_packages = ['my_package']
            source_space = 'src'
            source_subdir = None
            include_roscore = False

        self.properties = props()
        self.project_options = snapcraft.ProjectOptions()

        patcher = mock.patch('snapcraft.repo.Ubuntu')
        self.ubuntu_mock = patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch(
            'snapcraft.plugins.catkin._find_system_dependencies')
        self.dependencies_mock = patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch('snapcraft.plugins.catkin._Rosdep')
        self.rosdep_mock = patcher.start()
        self.addCleanup(patcher.stop)

def test_new_object_with_two_webhook_signals(settings):
    settings.WEBHOOKS_ENABLED = True
    project = f.ProjectFactory()
    f.WebhookFactory.create(project=project)
    f.WebhookFactory.create(project=project)

    objects = [
        f.IssueFactory.create(project=project),
        f.TaskFactory.create(project=project),
        f.UserStoryFactory.create(project=project),
        f.WikiPageFactory.create(project=project)
    ]

    response = Mock(status_code=200, headers={}, content="ok")
    response.elapsed.total_seconds.return_value = 100

    for obj in objects:
        with patch("taiga.webhooks.tasks.requests.Session.send", return_value=response) as session_send_mock:
            services.take_snapshot(obj, user=obj.owner, comment="test")
            assert session_send_mock.call_count == 2

    for obj in objects:
        with patch("taiga.webhooks.tasks.requests.Session.send", return_value=response) as session_send_mock:
            services.take_snapshot(obj, user=obj.owner, comment="test")
            assert session_send_mock.call_count == 2

    for obj in objects:
        with patch("taiga.webhooks.tasks.requests.Session.send", return_value=response) as session_send_mock:
            services.take_snapshot(obj, user=obj.owner)
            assert session_send_mock.call_count == 0

    for obj in objects:
        with patch("taiga.webhooks.tasks.requests.Session.send", return_value=response) as session_send_mock:
            services.take_snapshot(obj, user=obj.owner, comment="test", delete=True)
            assert session_send_mock.call_count == 2

    def setUp(self):
        super().setUp()

        class Options:
            build_parameters = []
            kconfigfile = None
            kconfigflavour = None
            kdefconfig = []
            kconfigs = []
            build_attributes = []

        self.options = Options()
        self.project_options = snapcraft.ProjectOptions(
            target_deb_arch=self.deb_arch)

        patcher = mock.patch('snapcraft.internal.common.run')
        self.run_mock = patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch('snapcraft.ProjectOptions.is_cross_compiling')
        patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch.dict(os.environ, {})
        self.env_mock = patcher.start()
        self.addCleanup(patcher.stop)

def test__common_submit(tmpdir, db):
    from Ganga.Core import BackendError
    j = Job()
    j.id = 0
    j.backend = db
    db._parent = j

    name = str(tmpdir.join('submit_script'))
    with open(name, 'w') as fd:
        fd.write(script_template.replace('###PARAMETRIC_INPUTDATA###', str([['a'], ['b']])))

    with patch('GangaDirac.Lib.Backends.DiracBase.execute', return_value={}):
        db.id = 1234
        db.actualCE = 'test'
        db.status = 'test'
        with pytest.raises(BackendError):
            db._common_submit(name)

        assert db.id is None, 'id not None'
        assert db.actualCE is None, 'actualCE not None'
        assert db.status is None, 'status not None'

    with patch('GangaDirac.Lib.Backends.DiracBase.execute', return_value={'OK': True, 'Value': 12345}) as execute:
        assert db._common_submit(name)

        execute.assert_called_once_with("execfile('%s')" % name)

        assert db.id == 12345, 'id not set'

    with patch('GangaDirac.Lib.Backends.DiracBase.execute', return_value={'OK': True, 'Value': [123, 456]}):
        with patch.object(db, '_setup_bulk_subjobs') as _setup_bulk_subjobs:
            db._common_submit(name)
            _setup_bulk_subjobs.assert_called_once_with([123, 456], name)

 def setUp(self):
     warnings.simplefilter("ignore", Warning)
     self.readListFromSettingsMock = patch('ReText.window.readListFromSettings', return_value=[]).start()
     self.writeListToSettingsMock  = patch('ReText.window.writeListToSettings').start()
     self.writeToSettingsMock      = patch('ReText.window.writeToSettings').start()
     self.globalSettingsMock       = patch('ReText.window.globalSettings', MagicMock(**ReText.configOptions)).start()
     self.fileSystemWatcherMock    = patch('ReText.window.QFileSystemWatcher').start()

def test_webhook_action_test(client, data):
    url1 = reverse('webhooks-test', kwargs={"pk": data.webhook1.pk})
    url2 = reverse('webhooks-test', kwargs={"pk": data.webhook2.pk})
    blocked_url = reverse('webhooks-test', kwargs={"pk": data.blocked_webhook.pk})

    users = [
        None,
        data.registered_user,
        data.project_owner
    ]

    with mock.patch('taiga.webhooks.tasks._send_request') as _send_request_mock:
        _send_request_mock.return_value = data.webhooklog1
        results = helper_test_http_method(client, 'post', url1, None, users)
        assert results == [404, 404, 200]
        assert _send_request_mock.called is True

    with mock.patch('taiga.webhooks.tasks._send_request') as _send_request_mock:
        _send_request_mock.return_value = data.webhooklog1
        results = helper_test_http_method(client, 'post', url2, None, users)
        assert results == [404, 404, 404]
        assert _send_request_mock.called is False

    with mock.patch('taiga.webhooks.tasks._send_request') as _send_request_mock:
        _send_request_mock.return_value = data.webhooklog1
        results = helper_test_http_method(client, 'post', blocked_url, None, users)
        assert results == [404, 404, 451]
        assert _send_request_mock.called is False

 def test_edit_post(self):
     perm = Permission.objects.get(codename='change_milestone') 
     self.admin.user_permissions.add(perm)
     with patch('traq.projects.forms.MilestoneForm.is_valid', return_value=True) as data:
         with patch('traq.projects.forms.MilestoneForm.save', return_value=True):
             response = self.client.post(reverse('milestones-edit', args=[self.milestone.pk,]))
     self.assertTrue(response.status_code, 302)

 def test_random_song(self):
     with mock.patch("pubbot.squeezecenter.receivers.command") as command:
         with mock.patch("random.choice") as choice:
             choice.side_effect = lambda x: x[0]
             r = receivers.random_song(None, content='random')
         command.assert_called_with("playlist loadtracks track.titlesearch=A")
     self.assertEqual(r['had_side_effect'], True)

def test_new_object_with_two_webhook(settings):
    settings.WEBHOOKS_ENABLED = True
    project = f.ProjectFactory()
    f.WebhookFactory.create(project=project)
    f.WebhookFactory.create(project=project)

    objects = [
        f.IssueFactory.create(project=project),
        f.TaskFactory.create(project=project),
        f.UserStoryFactory.create(project=project),
        f.WikiPageFactory.create(project=project)
    ]

    for obj in objects:
        with patch('taiga.webhooks.tasks.create_webhook') as create_webhook_mock:
            services.take_snapshot(obj, user=obj.owner, comment="test")
            assert create_webhook_mock.call_count == 2

    for obj in objects:
        with patch('taiga.webhooks.tasks.change_webhook') as change_webhook_mock:
            services.take_snapshot(obj, user=obj.owner, comment="test")
            assert change_webhook_mock.call_count == 2

    for obj in objects:
        with patch('taiga.webhooks.tasks.change_webhook') as change_webhook_mock:
            services.take_snapshot(obj, user=obj.owner)
            assert change_webhook_mock.call_count == 0

    for obj in objects:
        with patch('taiga.webhooks.tasks.delete_webhook') as delete_webhook_mock:
            services.take_snapshot(obj, user=obj.owner, comment="test", delete=True)
            assert delete_webhook_mock.call_count == 2

    def setUp(self):
        super().setUp()

        class Options:
            makefile = None
            make_parameters = []
            rust_features = []
            rust_revision = ""
            rust_channel = ""
            source_subdir = ""

        self.options = Options()
        self.project_options = snapcraft.ProjectOptions(target_deb_arch=self.deb_arch)

        patcher = mock.patch("snapcraft.internal.common.run")
        self.run_mock = patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch("snapcraft.internal.common.run_output")
        patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch("snapcraft.ProjectOptions.is_cross_compiling")
        patcher.start()
        self.addCleanup(patcher.stop)

        patcher = mock.patch.dict(os.environ, {})
        self.env_mock = patcher.start()
        self.addCleanup(patcher.stop)

def test_prettify(project_1_fixture):
    def colored_side_effect(v, c='', **kwargs):
        return '{}: {}{}'.format(c, v, kwargs)
    with patch('srmlf.project.colored',
               side_effect=colored_side_effect):
        with patch('prettytable.PrettyTable') as pt:
            with LocaleMock(('en_US', 'UTF-8'), [locale.LC_TIME,
                                                 locale.LC_MONETARY]):
                table = project_1_fixture.prettify()
                pt.assert_any_call(['red: Description{}',
                                    'red: Date{}',
                                    'red: Alice{}',
                                    'red: Bob{}'])

                assert isinstance(table, MagicMock)
                assert table.add_row.call_count == 4
                table.add_row.assert_any_call(
                    ['',
                     ': TOTAL{\'attrs\': [\'bold\']}',
                     ': %s{\'attrs\': [\'bold\']}'
                     % locale.currency(10.0),
                     ': %s{\'attrs\': [\'bold\']}'
                     % locale.currency(5.0)
                     ])
                table.add_row.assert_any_call(
                    ['',
                     '',
                     ': 66.67%{\'attrs\': [\'bold\']}',
                     ': 33.33%{\'attrs\': [\'bold\']}'
                     ])

def test_submission_save(submission_page, refresh_token):

    # Log in
    submission_page.config.refresh_token = refresh_token
    submission_page.oauth.authorize()

    # Test save on the submission
    with mock.patch('praw.objects.Submission.save') as save,            \
            mock.patch('praw.objects.Submission.unsave') as unsave:

        data = submission_page.content.get(submission_page.nav.absolute_index)

        # Save
        submission_page.controller.trigger('w')
        assert save.called
        assert data['saved'] is True

        # Unsave
        submission_page.controller.trigger('w')
        assert unsave.called
        assert data['saved'] is False

        # Save - exception
        save.side_effect = KeyboardInterrupt
        submission_page.controller.trigger('w')
        assert data['saved'] is False

def test_webhooks_when_update_task(settings):
    settings.WEBHOOKS_ENABLED = True
    project = f.ProjectFactory()
    f.WebhookFactory.create(project=project)
    f.WebhookFactory.create(project=project)

    obj = f.TaskFactory.create(project=project)

    with patch("taiga.webhooks.tasks._send_request") as send_request_mock:
        services.take_snapshot(obj, user=obj.owner)
        assert send_request_mock.call_count == 2

    obj.subject = "test webhook update"
    obj.save()

    with patch("taiga.webhooks.tasks._send_request") as send_request_mock:
        services.take_snapshot(obj, user=obj.owner, comment="test_comment")
        assert send_request_mock.call_count == 2

        (webhook_id, url, key, data) = send_request_mock.call_args[0]
        assert data["action"] == "change"
        assert data["type"] == "task"
        assert data["by"]["id"] == obj.owner.id
        assert "date" in data
        assert data["data"]["id"] == obj.id
        assert data["data"]["subject"] == obj.subject
        assert data["change"]["comment"] == "test_comment"
        assert data["change"]["diff"]["subject"]["to"] == data["data"]["subject"]
        assert data["change"]["diff"]["subject"]["from"] != data["data"]["subject"]