Lines Matching full:foo
45 class Foo(object): class
49 foo = 'bar' variable in Foo
60 foo_name = '%s.Foo' % __name__
63 def function(a, b=Foo): pass
407 class Foo(object): class
412 @patch.object(Foo, 'woot', staticmethod(lambda: sentinel.Patched))
414 self.assertEqual(Foo.woot(), sentinel.Patched)
417 self.assertEqual(Foo.woot(), sentinel.Static)
421 foo = sentinel.Foo
422 @patch.object(sentinel, 'Foo', 'Foo')
424 self.assertEqual(sentinel.Foo, 'Foo')
427 self.assertEqual(sentinel.Foo, foo)
431 class Foo(object): class
432 __slots__ = ('Foo',)
434 foo = Foo()
435 foo.Foo = sentinel.Foo
437 @patch.object(foo, 'Foo', 'Foo')
439 self.assertEqual(foo.Foo, 'Foo')
442 self.assertEqual(foo.Foo, sentinel.Foo)
449 class Foo(object): class
457 Foo = patch.object(Something, 'attribute', sentinel.Patched)(Foo)
459 f = Foo()
471 class Foo(object): class
481 Foo = patch('%s.something' % __name__)(Foo)
483 f = Foo()
510 foo = {'initial': object(), 'other': 'something'}
511 original = foo.copy()
513 @patch.dict(foo)
515 foo['a'] = 3
516 del foo['initial']
517 foo['other'] = 'something else'
521 self.assertEqual(foo, original)
523 @patch.dict(foo, {'a': 'b'})
525 self.assertEqual(len(foo), 3)
526 self.assertEqual(foo['a'], 'b')
530 self.assertEqual(foo, original)
532 @patch.dict(foo, [('a', 'b')])
534 self.assertEqual(len(foo), 3)
535 self.assertEqual(foo['a'], 'b')
539 self.assertEqual(foo, original)
543 foo = Container()
544 foo['initial'] = object()
545 foo['other'] = 'something'
547 original = foo.values.copy()
549 @patch.dict(foo)
551 foo['a'] = 3
552 del foo['initial']
553 foo['other'] = 'something else'
557 self.assertEqual(foo.values, original)
559 @patch.dict(foo, {'a': 'b'})
561 self.assertEqual(len(foo.values), 3)
562 self.assertEqual(foo['a'], 'b')
566 self.assertEqual(foo.values, original)
570 foo = {'initial': object(), 'other': 'something'}
571 original = foo.copy()
573 @patch.dict(foo, clear=True)
575 self.assertEqual(foo, {})
576 foo['a'] = 3
577 foo['other'] = 'something else'
581 self.assertEqual(foo, original)
583 @patch.dict(foo, {'a': 'b'}, clear=True)
585 self.assertEqual(foo, {'a': 'b'})
589 self.assertEqual(foo, original)
591 @patch.dict(foo, [('a', 'b')], clear=True)
593 self.assertEqual(foo, {'a': 'b'})
597 self.assertEqual(foo, original)
601 foo = Container()
602 foo['initial'] = object()
603 foo['other'] = 'something'
605 original = foo.values.copy()
607 @patch.dict(foo, clear=True)
609 self.assertEqual(foo.values, {})
610 foo['a'] = 3
611 foo['other'] = 'something else'
615 self.assertEqual(foo.values, original)
617 @patch.dict(foo, {'a': 'b'}, clear=True)
619 self.assertEqual(foo.values, {'a': 'b'})
623 self.assertEqual(foo.values, original)
627 foo = {'a': 'b'}
628 with patch.dict(foo, a='c') as patched:
630 self.assertEqual(foo, {'a': 'b'})
634 foo = {}
639 @patch.dict(foo)
646 foo = {}
648 @patch.dict(foo, {'a': 'b'})
655 self.assertEqual(foo, {})
673 self.assertEqual(support.target, {'foo': 'BAZ', 'bar': 'BAR'})
676 support.target = {'foo': 'BAZ'}
678 self.assertEqual(support.target, {'foo': 'BAZ'})
686 MockClass.z = 'foo'
692 MockClass.z = 'foo'
697 MockClass.z = 'foo'
703 MockClass.z = 'foo'
712 instance.z = 'foo'
747 patcher = patch.object(PTModule, 'something', 'foo')
751 self.assertEqual(replaced, 'foo')
759 d = {'foo': 'bar'}
779 this.assertEqual(d, {'foo': 'bar'})
781 this.assertEqual(d, {'foo': 'bar'})
783 Test = patch.dict(d, {'foo': 'bar'}, clear=True)(Test)
805 foo = 'foo' variable in PatchTest.test_get_only_proxy.Something
807 foo = 'foo' variable in PatchTest.test_get_only_proxy.SomethingElse
812 @patch.object(proxy, 'foo', 'bar')
814 self.assertEqual(proxy.foo, 'bar')
816 self.assertEqual(proxy.foo, 'foo')
817 self.assertEqual(thing.foo, 'foo')
818 self.assertNotIn('foo', proxy.__dict__)
823 foo = 'foo' variable in PatchTest.test_get_set_delete_proxy.Something
825 foo = 'foo' variable in PatchTest.test_get_set_delete_proxy.SomethingElse
830 @patch.object(proxy, 'foo', 'bar')
832 self.assertEqual(proxy.foo, 'bar')
834 self.assertEqual(proxy.foo, 'foo')
835 self.assertEqual(thing.foo, 'foo')
836 self.assertNotIn('foo', proxy.__dict__)
840 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
841 'foo': MagicMock()}
848 self.assertEqual(mock.foo.bar(), 33)
849 self.assertIsInstance(mock.foo, MagicMock)
853 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
854 'foo': MagicMock()}
856 patcher = patch.object(Foo, 'f', **kwargs)
861 self.assertEqual(mock.foo.bar(), 33)
862 self.assertIsInstance(mock.foo, MagicMock)
866 original = {'foo': 'bar'}
869 patcher = patch.dict(original, foo=3, bar=4, baz=5)
873 self.assertEqual(original, dict(foo=3, bar=4, baz=5))
885 foo = 'bar' variable in PatchTest.test_autospec.Boo
906 mock.foo.lower()
907 mock.foo.lower.assert_called_with()
908 self.assertRaises(AttributeError, getattr, mock.foo, 'bar')
928 self.assertIs(mock, Foo)
934 self.assertIsNot(Foo, mock)
939 test = patch.object(module, 'Foo', autospec=True)(function)
942 self.assertIsNot(Foo, mock)
962 self.assertRaises(AttributeError, getattr, function, 'foo')
971 #self.assertEqual(function.abc, 'foo')
979 with patch('%s.Foo.static_method' % __name__, autospec=True) as method:
980 Foo.static_method()
985 with patch('%s.Foo.class_method' % __name__, autospec=True) as method:
986 Foo.class_method()
1000 class Bar(Foo):
1013 FooClass = Foo
1028 self.assertIn(" name='Foo'", repr(mock))
1029 self.assertIn(" name='Foo.f'", repr(mock.f))
1030 self.assertIn(" name='Foo()'", repr(mock(None)))
1031 self.assertIn(" name='Foo().f'", repr(mock(None).f))
1037 @patch.object(Foo, 'f', object())
1064 patcher = patch.object(Foo, 'f', new_callable=NonCallableMagicMock)
1131 ValueError, patch.object, Foo, 'f', new=object(),
1142 ValueError, patch.object, Foo, 'f', new_callable=MagicMock,
1179 self.assertEqual(m.spec, Foo)
1184 original = Foo
1188 test.assertIsNot(Foo, original)
1189 test.assertIs(Foo, mock_foo)
1190 test.assertIsInstance(Foo, SomeClass)
1200 self.assertIs(Foo, original)
1204 original_foo = Foo
1205 original_f = Foo.f
1206 original_g = Foo.g
1209 patcher2 = patch.multiple(Foo, f=1, g=2)
1214 self.assertIs(Foo, original_foo)
1215 self.assertEqual(Foo.f, 1)
1216 self.assertEqual(Foo.g, 2)
1220 self.assertIs(Foo, original_foo)
1221 self.assertEqual(Foo.f, original_f)
1222 self.assertEqual(Foo.g, original_g)
1227 self.assertIs(Foo, original_foo)
1228 self.assertEqual(Foo.f, 3)
1229 self.assertEqual(Foo.g, 4)
1236 self.assertRaises(ValueError, patch.multiple, Foo)
1240 original_foo = Foo
1241 original_f = Foo.f
1242 original_g = Foo.g
1244 @patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT)
1245 def test(f, foo): argument
1246 self.assertIs(Foo, original_foo)
1247 self.assertIs(Foo.f, f)
1248 self.assertEqual(Foo.g, 3)
1249 self.assertIs(Foo.foo, foo)
1251 self.assertTrue(is_instance(foo, MagicMock))
1254 self.assertEqual(Foo.f, original_f)
1255 self.assertEqual(Foo.g, original_g)
1259 original_f = Foo.f
1260 original_g = Foo.g
1262 patcher = patch.object(Foo, 'f', 3)
1265 other = patch.object(Foo, 'g', DEFAULT)
1271 self.assertIs(Foo.g, g)
1272 self.assertEqual(Foo.f, 3)
1275 self.assertEqual(Foo.f, original_f)
1276 self.assertEqual(Foo.g, original_g)
1280 original_foo = Foo
1281 original_f = Foo.f
1282 original_g = Foo.g
1285 @patch.multiple(foo_name, foo=DEFAULT)
1292 @patch.multiple(foo_name, foo=DEFAULT)
1298 @patch.multiple(foo_name, foo=DEFAULT)
1304 foo = kwargs.pop('foo')
1307 self.assertIs(Foo, original_foo)
1308 self.assertIs(Foo.f, f)
1309 self.assertIs(Foo.g, g)
1310 self.assertIs(Foo.foo, foo)
1313 self.assertTrue(is_instance(foo, MagicMock))
1318 self.assertEqual(Foo.f, original_f)
1319 self.assertEqual(Foo.g, original_g)
1323 original_foo = Foo
1324 original_f = Foo.f
1325 original_g = Foo.g
1327 patcher = patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT)
1332 foo = result['foo']
1333 self.assertEqual(set(result), set(['f', 'foo']))
1335 self.assertIs(Foo, original_foo)
1336 self.assertIs(Foo.f, f)
1337 self.assertIs(Foo.foo, foo)
1339 self.assertTrue(is_instance(foo, MagicMock))
1343 self.assertEqual(Foo.f, original_f)
1344 self.assertEqual(Foo.g, original_g)
1349 original_foo = Foo
1350 original_f = Foo.f
1351 original_g = Foo.g
1355 def _test(self, f, foo): argument
1356 test.assertIs(Foo, original_foo)
1357 test.assertIs(Foo.f, f)
1358 test.assertEqual(Foo.g, 3)
1359 test.assertIs(Foo.foo, foo)
1361 test.assertTrue(is_instance(foo, MagicMock))
1363 def test_two(self, f, foo): argument
1364 self._test(f, foo)
1365 def test_one(self, f, foo): argument
1366 self._test(f, foo)
1369 foo_name, f=DEFAULT, g=3, foo=DEFAULT
1376 self.assertEqual(Foo.f, original_f)
1377 self.assertEqual(Foo.g, original_g)
1381 patcher = patch.multiple(Foo, blam='blam')
1384 patcher = patch.multiple(Foo, blam='blam', create=True)
1387 self.assertEqual(Foo.blam, 'blam')
1391 self.assertFalse(hasattr(Foo, 'blam'))
1397 patcher = patch.multiple(Foo, foo=DEFAULT, spec_set=['a', 'b'])
1400 self.assertEqual(Foo.foo, result['foo'])
1401 Foo.foo.a(1)
1402 Foo.foo.b(2)
1403 Foo.foo.a.assert_called_with(1)
1404 Foo.foo.b.assert_called_with(2)
1405 self.assertRaises(AttributeError, setattr, Foo.foo, 'c', None)
1415 Foo, f=DEFAULT, g=DEFAULT, new_callable=Thing
1419 self.assertIs(Foo.f, result['f'])
1420 self.assertIs(Foo.g, result['g'])
1421 self.assertIsInstance(Foo.f, Thing)
1422 self.assertIsInstance(Foo.g, Thing)
1423 self.assertIsNot(Foo.f, Foo.g)
1429 original_f = Foo.f
1430 original_g = Foo.g
1432 @patch.object(Foo, 'g', 1)
1433 @patch.object(Foo, 'missing', 1)
1434 @patch.object(Foo, 'f', 1)
1437 @patch.object(Foo, 'missing', 1)
1438 @patch.object(Foo, 'g', 1)
1439 @patch.object(Foo, 'f', 1)
1442 @patch.object(Foo, 'g', 1)
1443 @patch.object(Foo, 'f', 1)
1444 @patch.object(Foo, 'missing', 1)
1449 self.assertEqual(Foo.f, original_f)
1450 self.assertEqual(Foo.g, original_g)
1454 original_f = Foo.f
1455 original_g = Foo.g
1456 original_foo = Foo.foo
1461 @patch.object(Foo, 'g', 1)
1462 @patch.object(Foo, 'foo', new_callable=crasher)
1463 @patch.object(Foo, 'f', 1)
1466 @patch.object(Foo, 'foo', new_callable=crasher)
1467 @patch.object(Foo, 'g', 1)
1468 @patch.object(Foo, 'f', 1)
1471 @patch.object(Foo, 'g', 1)
1472 @patch.object(Foo, 'f', 1)
1473 @patch.object(Foo, 'foo', new_callable=crasher)
1478 self.assertEqual(Foo.f, original_f)
1479 self.assertEqual(Foo.g, original_g)
1480 self.assertEqual(Foo.foo, original_foo)
1484 original_f = Foo.f
1485 original_g = Foo.g
1487 patcher = patch.object(Foo, 'f', 1)
1490 good = patch.object(Foo, 'g', 1)
1493 bad = patch.object(Foo, 'missing', 1)
1503 self.assertEqual(Foo.f, original_f)
1504 self.assertEqual(Foo.g, original_g)
1508 original_f = Foo.f
1509 original_g = Foo.g
1510 original_foo = Foo.foo
1515 patcher = patch.object(Foo, 'f', 1)
1518 good = patch.object(Foo, 'g', 1)
1521 bad = patch.object(Foo, 'foo', new_callable=crasher)
1522 bad.attribute_name = 'foo'
1531 self.assertEqual(Foo.f, original_f)
1532 self.assertEqual(Foo.g, original_g)
1533 self.assertEqual(Foo.foo, original_foo)
1537 Foo = type('Foo', (str,), {'fish': 'tasty'})
1538 foo = Foo()
1539 @patch.multiple(foo, fish='nearly gone')
1541 self.assertEqual(foo.fish, 'nearly gone')
1544 self.assertEqual(foo.fish, 'tasty')
1547 @patch('unittest.mock.patch.TEST_PREFIX', 'foo')
1549 class Foo(object): class
1561 Foo = patch.object(Foo, 'thing', 'changed')(Foo)
1563 foo = Foo()
1564 self.assertEqual(foo.foo_one(), 'changed')
1565 self.assertEqual(foo.foo_two(), 'changed')
1566 self.assertEqual(foo.test_one(), 'original')
1567 self.assertEqual(foo.test_two(), 'original')
1572 class Foo(object): class
1583 Foo = patch.dict(the_dict, key='changed')(Foo)
1585 foo =Foo()
1586 self.assertEqual(foo.bar_one(), {'key': 'changed'})
1587 self.assertEqual(foo.bar_two(), {'key': 'changed'})
1588 self.assertEqual(foo.test_one(), {'key': 'original'})
1589 self.assertEqual(foo.test_two(), {'key': 'original'})
1767 spec = ('foo', 'bar')
1812 def foo(x=0): function
1815 with patch.object(foo, '__defaults__', (1, )):
1816 self.assertEqual(foo(), 1)
1817 self.assertEqual(foo(), 0)
1819 with patch.object(foo, '__doc__', "FUN"):
1820 self.assertEqual(foo.__doc__, "FUN")
1821 self.assertEqual(foo.__doc__, "TEST")
1823 with patch.object(foo, '__module__', "testpatch2"):
1824 self.assertEqual(foo.__module__, "testpatch2")
1825 self.assertEqual(foo.__module__, 'unittest.test.testmock.testpatch')
1827 with patch.object(foo, '__annotations__', dict([('s', 1, )])):
1828 self.assertEqual(foo.__annotations__, dict([('s', 1, )]))
1829 self.assertEqual(foo.__annotations__, dict())
1831 def foo(*a, x=0): function
1833 with patch.object(foo, '__kwdefaults__', dict([('x', 1, )])):
1834 self.assertEqual(foo(), 1)
1835 self.assertEqual(foo(), 0)