def setUp(self):
     self.resource_url = 'http://example.com/resource'
     self.provider = InternalProvider()
class InternalProviderTestCase(TestCase):

    def setUp(self):
        self.resource_url = 'http://example.com/resource'
        self.provider = InternalProvider()

    def test_data_attribute_raises_required(self):
        self.provider.foo = None

        with self.assertRaises(NotImplementedError):
            self.provider._data_attribute('foo', required=True)

    def test_data_attribute_does_not_raise(self):
        self.provider.foo = None
        result = self.provider._data_attribute('foo')
        self.assertIsNone(result)

    def test_data_attribute_calls_callable(self):
        self.provider.foo = Mock()
        self.provider.foo.return_value = 'foo'
        result = self.provider._data_attribute('foo')
        self.assertEqual('foo', result)

    def test_data_attribute_property(self):
        self.provider.foo = 'foo'
        result = self.provider._data_attribute('foo')
        self.assertEqual('foo', result)

    def test_build_resource_undefined_type(self):
        # Setup for some type not defined - nothing should break
        self.provider.resource_type = 'flash'
        self.provider.html = 'HTML'
        self.provider.foo = 'foo'
        self.provider.author_name = 'John Galt'

        resource = self.provider._build_resource(**{'url': self.resource_url})

        # Base things
        self.assertEqual('1.0', resource['version'])
        self.assertEqual('flash', resource['type'])

        # Should skip
        self.assertNotIn('html', resource)

        # Not an OEmbed param
        self.assertNotIn('foo', resource)

        # Optional param
        self.assertEqual(resource['author_name'], self.provider.author_name)

    def test_build_resource_valid_type(self):
        # Ensure that we do the right thing for types we know about
        self.provider.resource_type = 'video'
        self.provider.html = 'FooBar'
        self.provider._params['maxwidth'] = 100
        self.provider._params['maxheight'] = 100
        self.provider.author_name = 'John Galt'

        resource = self.provider._build_resource(**{'url': self.resource_url})

        # Base things
        self.assertEqual('1.0', resource['version'])
        self.assertEqual('video', resource['type'])

        self.assertEqual('FooBar', resource['html'])
        self.assertEqual(100, resource['width'])
        self.assertEqual(100, resource['height'])

        # Optional param
        self.assertEqual('John Galt', resource['author_name'])

    @patch('monocle.providers.cache')
    def test_get_resource_cached_is_stale(self, mock_cache):
        # Update django settings
        setattr(settings, 'MONOCLE_CACHE_INTERNAL_PROVIDERS', True)

        resource = Resource(self.resource_url)
        resource.created = resource.created - (60*60*24*365*10)

        mock_cache.get_or_prime = mock_cache
        mock_cache.return_value = (resource, False)
        self.provider._build_resource = Mock(return_value=resource)

        self.assertTrue(resource.is_stale)
        resource = self.provider.get_resource(self.resource_url)
        self.assertFalse(resource.is_stale)
        self.assertTrue(self.provider._build_resource.called)

    @patch('monocle.providers.cache')
    def test_get_resource_cached_is_primed(self, mock_cache):
        # Update django settings
        setattr(settings, 'MONOCLE_CACHE_INTERNAL_PROVIDERS', True)

        resource = Resource(self.resource_url)

        mock_cache.get_or_prime = mock_cache
        mock_cache.return_value = (resource, True)
        self.provider._build_resource = Mock(return_value=resource)

        self.assertFalse(resource.is_stale)
        resource = self.provider.get_resource(self.resource_url)
        self.assertFalse(resource.is_stale)
        self.assertTrue(self.provider._build_resource.called)

    def test_nearest_allowed_size_returns_original_size(self):
        self.provider.DIMENSIONS = [(50, 50), (100, 100), (200, 200)]
        self.assertEqual((25, 25), self.provider.nearest_allowed_size(25, 25))

    def test_nearest_allowed_size_returns_requested_max(self):
        self.provider.DIMENSIONS = [(150, 150), (200, 200)]

        nearest = self.provider.nearest_allowed_size(100, 100, maxwidth=50, maxheight=50)

        self.assertEqual((50, 50), nearest)

    def test_nearest_allowed_size_gets_nearest_size(self):
        self.provider.DIMENSIONS = [(50, 50), (100, 100), (200, 200)]

        nearest = self.provider.nearest_allowed_size(100, 100, maxwidth=500, maxheight=500)

        self.assertEqual((100, 100), nearest)