Lines Matching full:foo
46 class Foo(object): class
50 foo = 'bar' variable in Foo
61 foo_name = '%s.Foo' % __name__
64 def function(a, b=Foo): pass
408 class Foo(object): class
413 @patch.object(Foo, 'woot', staticmethod(lambda: sentinel.Patched))
415 self.assertEqual(Foo.woot(), sentinel.Patched)
418 self.assertEqual(Foo.woot(), sentinel.Static)
422 foo = sentinel.Foo
423 @patch.object(sentinel, 'Foo', 'Foo')
425 self.assertEqual(sentinel.Foo, 'Foo')
428 self.assertEqual(sentinel.Foo, foo)
432 class Foo(object): class
433 __slots__ = ('Foo',)
435 foo = Foo()
436 foo.Foo = sentinel.Foo
438 @patch.object(foo, 'Foo', 'Foo')
440 self.assertEqual(foo.Foo, 'Foo')
443 self.assertEqual(foo.Foo, sentinel.Foo)
450 class Foo(object): class
458 Foo = patch.object(Something, 'attribute', sentinel.Patched)(Foo)
460 f = Foo()
472 class Foo(object): class
482 Foo = patch('%s.something' % __name__)(Foo)
484 f = Foo()
511 foo = {'initial': object(), 'other': 'something'}
512 original = foo.copy()
514 @patch.dict(foo)
516 foo['a'] = 3
517 del foo['initial']
518 foo['other'] = 'something else'
522 self.assertEqual(foo, original)
524 @patch.dict(foo, {'a': 'b'})
526 self.assertEqual(len(foo), 3)
527 self.assertEqual(foo['a'], 'b')
531 self.assertEqual(foo, original)
533 @patch.dict(foo, [('a', 'b')])
535 self.assertEqual(len(foo), 3)
536 self.assertEqual(foo['a'], 'b')
540 self.assertEqual(foo, original)
544 foo = Container()
545 foo['initial'] = object()
546 foo['other'] = 'something'
548 original = foo.values.copy()
550 @patch.dict(foo)
552 foo['a'] = 3
553 del foo['initial']
554 foo['other'] = 'something else'
558 self.assertEqual(foo.values, original)
560 @patch.dict(foo, {'a': 'b'})
562 self.assertEqual(len(foo.values), 3)
563 self.assertEqual(foo['a'], 'b')
567 self.assertEqual(foo.values, original)
571 foo = {'initial': object(), 'other': 'something'}
572 original = foo.copy()
574 @patch.dict(foo, clear=True)
576 self.assertEqual(foo, {})
577 foo['a'] = 3
578 foo['other'] = 'something else'
582 self.assertEqual(foo, original)
584 @patch.dict(foo, {'a': 'b'}, clear=True)
586 self.assertEqual(foo, {'a': 'b'})
590 self.assertEqual(foo, original)
592 @patch.dict(foo, [('a', 'b')], clear=True)
594 self.assertEqual(foo, {'a': 'b'})
598 self.assertEqual(foo, original)
602 foo = Container()
603 foo['initial'] = object()
604 foo['other'] = 'something'
606 original = foo.values.copy()
608 @patch.dict(foo, clear=True)
610 self.assertEqual(foo.values, {})
611 foo['a'] = 3
612 foo['other'] = 'something else'
616 self.assertEqual(foo.values, original)
618 @patch.dict(foo, {'a': 'b'}, clear=True)
620 self.assertEqual(foo.values, {'a': 'b'})
624 self.assertEqual(foo.values, original)
628 foo = {'a': 'b'}
629 with patch.dict(foo, a='c') as patched:
631 self.assertEqual(foo, {'a': 'b'})
635 foo = {}
640 @patch.dict(foo)
647 foo = {}
649 @patch.dict(foo, {'a': 'b'})
656 self.assertEqual(foo, {})
674 self.assertEqual(support.target, {'foo': 'BAZ', 'bar': 'BAR'})
677 support.target = {'foo': 'BAZ'}
679 self.assertEqual(support.target, {'foo': 'BAZ'})
687 MockClass.z = 'foo'
693 MockClass.z = 'foo'
698 MockClass.z = 'foo'
704 MockClass.z = 'foo'
713 instance.z = 'foo'
748 patcher = patch.object(PTModule, 'something', 'foo')
752 self.assertEqual(replaced, 'foo')
760 d = {'foo': 'bar'}
774 d = {'foo': 'bar'}
788 this.assertEqual(d, {'foo': 'bar'})
790 this.assertEqual(d, {'foo': 'bar'})
792 Test = patch.dict(d, {'foo': 'bar'}, clear=True)(Test)
814 foo = 'foo' variable in PatchTest.test_get_only_proxy.Something
816 foo = 'foo' variable in PatchTest.test_get_only_proxy.SomethingElse
821 @patch.object(proxy, 'foo', 'bar')
823 self.assertEqual(proxy.foo, 'bar')
825 self.assertEqual(proxy.foo, 'foo')
826 self.assertEqual(thing.foo, 'foo')
827 self.assertNotIn('foo', proxy.__dict__)
832 foo = 'foo' variable in PatchTest.test_get_set_delete_proxy.Something
834 foo = 'foo' variable in PatchTest.test_get_set_delete_proxy.SomethingElse
839 @patch.object(proxy, 'foo', 'bar')
841 self.assertEqual(proxy.foo, 'bar')
843 self.assertEqual(proxy.foo, 'foo')
844 self.assertEqual(thing.foo, 'foo')
845 self.assertNotIn('foo', proxy.__dict__)
849 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
850 'foo': MagicMock()}
857 self.assertEqual(mock.foo.bar(), 33)
858 self.assertIsInstance(mock.foo, MagicMock)
862 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
863 'foo': MagicMock()}
865 patcher = patch.object(Foo, 'f', **kwargs)
870 self.assertEqual(mock.foo.bar(), 33)
871 self.assertIsInstance(mock.foo, MagicMock)
875 original = {'foo': 'bar'}
878 patcher = patch.dict(original, foo=3, bar=4, baz=5)
882 self.assertEqual(original, dict(foo=3, bar=4, baz=5))
894 foo = 'bar' variable in PatchTest.test_autospec.Boo
915 mock.foo.lower()
916 mock.foo.lower.assert_called_with()
917 self.assertRaises(AttributeError, getattr, mock.foo, 'bar')
937 self.assertIs(mock, Foo)
943 self.assertIsNot(Foo, mock)
948 test = patch.object(module, 'Foo', autospec=True)(function)
951 self.assertIsNot(Foo, mock)
971 self.assertRaises(AttributeError, getattr, function, 'foo')
980 #self.assertEqual(function.abc, 'foo')
988 with patch('%s.Foo.static_method' % __name__, autospec=True) as method:
989 Foo.static_method()
994 with patch('%s.Foo.class_method' % __name__, autospec=True) as method:
995 Foo.class_method()
1001 class Foo: class
1005 Foo.static_method(1, 2, c=3)
1007 with patch.object(Foo, 'static_method', autospec=True) as method:
1016 class Foo: class
1020 Foo.class_method(1, 2, c=3)
1022 with patch.object(Foo, 'class_method', autospec=True) as method:
1039 class Bar(Foo):
1052 FooClass = Foo
1067 self.assertIn(" name='Foo'", repr(mock))
1068 self.assertIn(" name='Foo.f'", repr(mock.f))
1069 self.assertIn(" name='Foo()'", repr(mock(None)))
1070 self.assertIn(" name='Foo().f'", repr(mock(None).f))
1076 @patch.object(Foo, 'f', object())
1103 patcher = patch.object(Foo, 'f', new_callable=NonCallableMagicMock)
1170 ValueError, patch.object, Foo, 'f', new=object(),
1181 ValueError, patch.object, Foo, 'f', new_callable=MagicMock,
1218 self.assertEqual(m.spec, Foo)
1223 original = Foo
1227 test.assertIsNot(Foo, original)
1228 test.assertIs(Foo, mock_foo)
1229 test.assertIsInstance(Foo, SomeClass)
1239 self.assertIs(Foo, original)
1243 original_foo = Foo
1244 original_f = Foo.f
1245 original_g = Foo.g
1248 patcher2 = patch.multiple(Foo, f=1, g=2)
1253 self.assertIs(Foo, original_foo)
1254 self.assertEqual(Foo.f, 1)
1255 self.assertEqual(Foo.g, 2)
1259 self.assertIs(Foo, original_foo)
1260 self.assertEqual(Foo.f, original_f)
1261 self.assertEqual(Foo.g, original_g)
1266 self.assertIs(Foo, original_foo)
1267 self.assertEqual(Foo.f, 3)
1268 self.assertEqual(Foo.g, 4)
1275 self.assertRaises(ValueError, patch.multiple, Foo)
1279 original_foo = Foo
1280 original_f = Foo.f
1281 original_g = Foo.g
1283 @patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT)
1284 def test(f, foo): argument
1285 self.assertIs(Foo, original_foo)
1286 self.assertIs(Foo.f, f)
1287 self.assertEqual(Foo.g, 3)
1288 self.assertIs(Foo.foo, foo)
1290 self.assertTrue(is_instance(foo, MagicMock))
1293 self.assertEqual(Foo.f, original_f)
1294 self.assertEqual(Foo.g, original_g)
1298 original_f = Foo.f
1299 original_g = Foo.g
1301 patcher = patch.object(Foo, 'f', 3)
1304 other = patch.object(Foo, 'g', DEFAULT)
1310 self.assertIs(Foo.g, g)
1311 self.assertEqual(Foo.f, 3)
1314 self.assertEqual(Foo.f, original_f)
1315 self.assertEqual(Foo.g, original_g)
1319 original_foo = Foo
1320 original_f = Foo.f
1321 original_g = Foo.g
1324 @patch.multiple(foo_name, foo=DEFAULT)
1331 @patch.multiple(foo_name, foo=DEFAULT)
1337 @patch.multiple(foo_name, foo=DEFAULT)
1343 foo = kwargs.pop('foo')
1346 self.assertIs(Foo, original_foo)
1347 self.assertIs(Foo.f, f)
1348 self.assertIs(Foo.g, g)
1349 self.assertIs(Foo.foo, foo)
1352 self.assertTrue(is_instance(foo, MagicMock))
1357 self.assertEqual(Foo.f, original_f)
1358 self.assertEqual(Foo.g, original_g)
1362 original_foo = Foo
1363 original_f = Foo.f
1364 original_g = Foo.g
1366 patcher = patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT)
1371 foo = result['foo']
1372 self.assertEqual(set(result), set(['f', 'foo']))
1374 self.assertIs(Foo, original_foo)
1375 self.assertIs(Foo.f, f)
1376 self.assertIs(Foo.foo, foo)
1378 self.assertTrue(is_instance(foo, MagicMock))
1382 self.assertEqual(Foo.f, original_f)
1383 self.assertEqual(Foo.g, original_g)
1388 original_foo = Foo
1389 original_f = Foo.f
1390 original_g = Foo.g
1394 def _test(self, f, foo): argument
1395 test.assertIs(Foo, original_foo)
1396 test.assertIs(Foo.f, f)
1397 test.assertEqual(Foo.g, 3)
1398 test.assertIs(Foo.foo, foo)
1400 test.assertTrue(is_instance(foo, MagicMock))
1402 def test_two(self, f, foo): argument
1403 self._test(f, foo)
1404 def test_one(self, f, foo): argument
1405 self._test(f, foo)
1408 foo_name, f=DEFAULT, g=3, foo=DEFAULT
1415 self.assertEqual(Foo.f, original_f)
1416 self.assertEqual(Foo.g, original_g)
1420 patcher = patch.multiple(Foo, blam='blam')
1423 patcher = patch.multiple(Foo, blam='blam', create=True)
1426 self.assertEqual(Foo.blam, 'blam')
1430 self.assertFalse(hasattr(Foo, 'blam'))
1436 patcher = patch.multiple(Foo, foo=DEFAULT, spec_set=['a', 'b'])
1439 self.assertEqual(Foo.foo, result['foo'])
1440 Foo.foo.a(1)
1441 Foo.foo.b(2)
1442 Foo.foo.a.assert_called_with(1)
1443 Foo.foo.b.assert_called_with(2)
1444 self.assertRaises(AttributeError, setattr, Foo.foo, 'c', None)
1454 Foo, f=DEFAULT, g=DEFAULT, new_callable=Thing
1458 self.assertIs(Foo.f, result['f'])
1459 self.assertIs(Foo.g, result['g'])
1460 self.assertIsInstance(Foo.f, Thing)
1461 self.assertIsInstance(Foo.g, Thing)
1462 self.assertIsNot(Foo.f, Foo.g)
1468 original_f = Foo.f
1469 original_g = Foo.g
1471 @patch.object(Foo, 'g', 1)
1472 @patch.object(Foo, 'missing', 1)
1473 @patch.object(Foo, 'f', 1)
1476 @patch.object(Foo, 'missing', 1)
1477 @patch.object(Foo, 'g', 1)
1478 @patch.object(Foo, 'f', 1)
1481 @patch.object(Foo, 'g', 1)
1482 @patch.object(Foo, 'f', 1)
1483 @patch.object(Foo, 'missing', 1)
1488 self.assertEqual(Foo.f, original_f)
1489 self.assertEqual(Foo.g, original_g)
1493 original_f = Foo.f
1494 original_g = Foo.g
1495 original_foo = Foo.foo
1500 @patch.object(Foo, 'g', 1)
1501 @patch.object(Foo, 'foo', new_callable=crasher)
1502 @patch.object(Foo, 'f', 1)
1505 @patch.object(Foo, 'foo', new_callable=crasher)
1506 @patch.object(Foo, 'g', 1)
1507 @patch.object(Foo, 'f', 1)
1510 @patch.object(Foo, 'g', 1)
1511 @patch.object(Foo, 'f', 1)
1512 @patch.object(Foo, 'foo', new_callable=crasher)
1517 self.assertEqual(Foo.f, original_f)
1518 self.assertEqual(Foo.g, original_g)
1519 self.assertEqual(Foo.foo, original_foo)
1523 original_f = Foo.f
1524 original_g = Foo.g
1526 patcher = patch.object(Foo, 'f', 1)
1529 good = patch.object(Foo, 'g', 1)
1532 bad = patch.object(Foo, 'missing', 1)
1542 self.assertEqual(Foo.f, original_f)
1543 self.assertEqual(Foo.g, original_g)
1547 original_f = Foo.f
1548 original_g = Foo.g
1549 original_foo = Foo.foo
1554 patcher = patch.object(Foo, 'f', 1)
1557 good = patch.object(Foo, 'g', 1)
1560 bad = patch.object(Foo, 'foo', new_callable=crasher)
1561 bad.attribute_name = 'foo'
1570 self.assertEqual(Foo.f, original_f)
1571 self.assertEqual(Foo.g, original_g)
1572 self.assertEqual(Foo.foo, original_foo)
1576 Foo = type('Foo', (str,), {'fish': 'tasty'})
1577 foo = Foo()
1578 @patch.multiple(foo, fish='nearly gone')
1580 self.assertEqual(foo.fish, 'nearly gone')
1583 self.assertEqual(foo.fish, 'tasty')
1586 @patch('unittest.mock.patch.TEST_PREFIX', 'foo')
1588 class Foo(object): class
1600 Foo = patch.object(Foo, 'thing', 'changed')(Foo)
1602 foo = Foo()
1603 self.assertEqual(foo.foo_one(), 'changed')
1604 self.assertEqual(foo.foo_two(), 'changed')
1605 self.assertEqual(foo.test_one(), 'original')
1606 self.assertEqual(foo.test_two(), 'original')
1611 class Foo(object): class
1622 Foo = patch.dict(the_dict, key='changed')(Foo)
1624 foo =Foo()
1625 self.assertEqual(foo.bar_one(), {'key': 'changed'})
1626 self.assertEqual(foo.bar_two(), {'key': 'changed'})
1627 self.assertEqual(foo.test_one(), {'key': 'original'})
1628 self.assertEqual(foo.test_two(), {'key': 'original'})
1806 spec = ('foo', 'bar')
1901 def foo(x=0): function
1904 with patch.object(foo, '__defaults__', (1, )):
1905 self.assertEqual(foo(), 1)
1906 self.assertEqual(foo(), 0)
1908 orig_doc = foo.__doc__
1909 with patch.object(foo, '__doc__', "FUN"):
1910 self.assertEqual(foo.__doc__, "FUN")
1911 self.assertEqual(foo.__doc__, orig_doc)
1913 with patch.object(foo, '__module__', "testpatch2"):
1914 self.assertEqual(foo.__module__, "testpatch2")
1915 self.assertEqual(foo.__module__, 'unittest.test.testmock.testpatch')
1917 with patch.object(foo, '__annotations__', dict([('s', 1, )])):
1918 self.assertEqual(foo.__annotations__, dict([('s', 1, )]))
1919 self.assertEqual(foo.__annotations__, dict())
1921 def foo(*a, x=0): function
1923 with patch.object(foo, '__kwdefaults__', dict([('x', 1, )])):
1924 self.assertEqual(foo(), 1)
1925 self.assertEqual(foo(), 0)
1928 foo = OrderedDict()
1929 foo['a'] = object()
1930 foo['b'] = 'python'
1932 original = foo.copy()
1934 patched_values = list(foo.items()) + update_values
1936 with patch.dict(foo, OrderedDict(update_values)):
1937 self.assertEqual(list(foo.items()), patched_values)
1939 self.assertEqual(foo, original)
1941 with patch.dict(foo, update_values):
1942 self.assertEqual(list(foo.items()), patched_values)
1944 self.assertEqual(foo, original)
1966 class Foo: class
1969 for target in ['', 12, Foo()]: