foreman_docker 3.0.0 → 3.1.0

data/test/units/docker_container_wizard_states/image_test.rb

@@ -0,0 +1,84 @@
+require 'test_plugin_helper'
+
+module DockerContainerWizardStates
+  class ImageTest < ActiveSupport::TestCase
+    let(:image) { 'centos' }
+    let(:tags) { ['latest', '5', '4.3'] }
+    let(:docker_hub) { Service::RegistryApi.new(url: 'https://nothub.com') }
+    let(:registry) { FactoryGirl.create(:docker_registry) }
+    let(:compute_resource) { FactoryGirl.create(:docker_cr) }
+    let(:image_search_service) { ForemanDocker::ImageSearch.new }
+    let(:wizard_state) do
+      DockerContainerWizardState.create
+    end
+    let(:preliminary) do
+      DockerContainerWizardStates::Preliminary.create(
+        compute_resource: compute_resource,
+        wizard_state: wizard_state
+      )
+    end
+
+    subject do
+      Image.new(
+        repository_name: image,
+        tag: tags.first,
+        wizard_state: wizard_state
+      )
+    end
+
+    setup do
+      ForemanDocker::ImageSearch.any_instance.unstub(:available?)
+      wizard_state.preliminary = preliminary
+      Service::RegistryApi.stubs(:docker_hub).returns(docker_hub)
+    end
+
+
+    describe 'it validates that the image is available' do
+      test 'validates via the image_search_service' do
+        DockerContainerWizardStates::Image.any_instance
+                                          .stubs(:image_search_service)
+                                          .returns(image_search_service)
+        available = [true, false].sample
+        image_search_service.expects(:available?)
+                            .with("#{image}:#{tags.first}").at_least_once
+                            .returns(available)
+        assert_equal available, subject.valid?
+      end
+
+      context 'when no registy is set' do
+        test 'it queries the compute_resource and docker_hub' do
+          compute_resource.expects(:image).with(image).at_least_once
+                          .returns(image)
+          compute_resource.expects(:tags_for_local_image).at_least_once
+                          .with(image, tags.first)
+                          .returns([])
+          docker_hub.expects(:tags).at_least_once
+                    .returns([])
+
+          subject.validate
+        end
+      end
+
+      context 'when a registy is set' do
+        setup do
+          subject.stubs(:registry_id).returns(registry.id)
+          DockerRegistry.expects(:find).with(registry.id)
+                        .returns(registry)
+        end
+
+        test 'it queries the compute_resource and registry' do
+          compute_resource.expects(:image).with(image).at_least_once
+                          .returns(image)
+          compute_resource.expects(:tags_for_local_image).at_least_once
+                          .with(image, tags.first)
+                          .returns([])
+          docker_hub.expects(:tags).never
+          registry.api.expects(:tags).with(image, tags.first).at_least_once
+                  .returns([])
+
+          subject.validate
+        end
+      end
+    end
+  end
+end

data/test/units/docker_registry_test.rb

@@ -1,6 +1,8 @@
 require 'test_plugin_helper'
 
 class DockerRegistryTest < ActiveSupport::TestCase
+  subject { FactoryGirl.create(:docker_registry) }
+
   test 'used_location_ids should return correct location ids' do
     location = FactoryGirl.build(:location)
     r = as_admin do
@@ -29,21 +31,36 @@ class DockerRegistryTest < ActiveSupport::TestCase
   should validate_uniqueness_of(:name)
   should validate_uniqueness_of(:url)
 
-  context 'attempt to login' do
+  describe 'registry validation' do
     setup do
-      @registry = FactoryGirl.build(:docker_registry)
-      @registry.unstub(:attempt_login)
+      subject.unstub(:attempt_login)
+    end
+
+    test 'is valid when the api is ok' do
+      subject.api.expects(:ok?).returns(true)
+      assert subject.valid?
     end
 
-    test 'before creating a registry' do
-      RestClient::Resource.any_instance.expects(:get)
-      assert @registry.valid?
+    test 'is not valid when api is not ok' do
+      subject.api.expects(:ok?)
+        .raises(Docker::Error::AuthenticationError)
+      refute subject.valid?
     end
+  end
+
+  describe '#api' do
+    let(:api) { subject.api }
+
+    test 'returns a RegistryApi instance' do
+      assert_kind_of Service::RegistryApi, api
+    end
+  end
+
+  describe '#api' do
+    let(:api) { subject.api }
 
-    test 'display errors in case authentication failed' do
-      RestClient::Resource.any_instance.expects(:get).
-        raises(Docker::Error::AuthenticationError)
-      refute @registry.valid?
+    test 'returns a RegistryApi instance' do
+      assert_kind_of Service::RegistryApi, api
     end
   end
 end

data/test/units/foreman_docker/compute_resource_extensions_test.rb

@@ -0,0 +1,10 @@
+require 'test_plugin_helper'
+
+module ForemanDocker
+  class ComputeResourceExtensionsTest < ActiveSupport::TestCase
+    test 'ComputeResource::providers_requiring_url returns expected providers' do
+      expected_providers = "Docker, Libvirt, oVirt, OpenStack and Rackspace"
+      assert_equal expected_providers, ComputeResource.providers_requiring_url
+    end
+  end
+end

data/test/units/image_search_service_test.rb

@@ -0,0 +1,188 @@
+require 'test_plugin_helper'
+
+class ImageSearchServiceTest < ActiveSupport::TestCase
+  let(:compute_resource) { FactoryGirl.create(:docker_cr) }
+  let(:registry) { FactoryGirl.create(:docker_registry).api }
+  let(:term) { 'centos' }
+  let(:query) { { term: term, tags: 'false' } }
+
+  subject { ForemanDocker::ImageSearch.new(compute_resource, registry) }
+
+  setup do
+    stub_registry_api
+  end
+
+  describe '#add_source' do
+    setup do
+      subject.instance_variable_set(:@sources, {})
+    end
+
+    test 'adds a compute resource to @sources[:compute_resource]' do
+      subject.add_source(compute_resource)
+      assert_equal compute_resource,
+                   subject.instance_variable_get(:@sources)[:compute_resource].first
+    end
+
+    test 'adds a registry to @sources[:registry]' do
+      subject.add_source(registry)
+      assert_equal registry,
+                   subject.instance_variable_get(:@sources)[:registry].first
+    end
+  end
+
+  describe '#remove_source' do
+    test 'removes a registry source from @sources' do
+      refute subject.instance_variable_get(:@sources)[:registry].empty?
+      subject.remove_source(registry)
+      assert subject.instance_variable_get(:@sources)[:registry].empty?
+    end
+
+    test 'removes a compute_resource source from @sources' do
+      refute subject.instance_variable_get(:@sources)[:compute_resource].empty?
+      subject.remove_source(compute_resource)
+      assert subject.instance_variable_get(:@sources)[:compute_resource].empty?
+    end
+  end
+
+  describe '#search' do
+    test 'returns {"name" => value } pairs' do
+      return_result = Hash.new
+      return_result.stubs(:info).returns({ 'RepoTags' => ["#{term}:latest"]})
+      compute_resource.stubs(:local_images).with(term)
+        .returns([return_result])
+      result = subject.search(query)
+      assert_equal({"name" => term}, result.first)
+    end
+
+    context 'tags is false' do
+      test 'calls #images with term as query' do
+        subject.expects(:images).with(term)
+          .returns([])
+        subject.search(query)
+      end
+    end
+
+    context 'tags is "true"' do
+      setup do
+        query[:tags] = 'true'
+      end
+
+      test 'calls #tags with term as query' do
+        subject.expects(:tags).with(term)
+          .returns([])
+        subject.search(query)
+      end
+    end
+  end
+
+  describe '#images' do
+    context 'a compute_resource set' do
+      test 'calls #search_compute_resource with term as query' do
+        subject.expects(:compute_resource_search).with(compute_resource, term)
+          .returns([])
+        subject.images(term)
+      end
+    end
+
+    context 'no compute_resource is set' do
+      setup do
+        subject.remove_source(compute_resource)
+      end
+
+      test 'does not call #search_compute_resource' do
+        subject.expects(:compute_resource_search).with(compute_resource, term)
+          .never
+        subject.images(term)
+      end
+    end
+
+    context 'a registry is set' do
+      test 'calls #search_registry' do
+        subject.expects(:registry_search).with(registry, term)
+          .returns([])
+        subject.images(term)
+      end
+    end
+
+    context 'no registry is set' do
+      setup do
+        subject.remove_source(registry)
+      end
+
+      test 'does not call #search_registry' do
+        subject.expects(:registry_search).with(registry, term)
+          .never
+        subject.images(term)
+      end
+    end
+  end
+
+  describe '#tags' do
+    let(:tag) { 'latest' }
+    let(:query) { "#{term}:#{tag}" }
+
+    context 'a compute_resource set' do
+      test 'calls #compute_resource with image name and tag' do
+        subject.expects(:compute_resource_tags).with(compute_resource, term, tag)
+          .returns([])
+        subject.tags(query)
+      end
+    end
+
+    context 'no compute_resource is set' do
+      setup do
+        subject.remove_source(compute_resource)
+      end
+
+      test 'does not call #search_compute_resource' do
+        subject.expects(:compute_resource_tags).with(compute_resource, term, tag)
+          .never
+        subject.tags(query)
+      end
+    end
+
+    context 'a registry is set' do
+      setup do
+        subject.remove_source(compute_resource)
+      end
+
+      test 'calls #registry_tags with image name and tag' do
+        subject.expects(:registry_tags).with(registry, term, tag)
+          .returns([])
+        subject.tags(query)
+      end
+    end
+
+    context 'no registry is set' do
+      setup do
+        subject.remove_source(registry)
+      end
+
+      test 'does not call #registry_tags' do
+        subject.expects(:registry_search).with(registry, term, tag)
+          .never
+        subject.images(query)
+      end
+    end
+  end
+
+  describe '#available?' do
+    test 'calls #tags with query' do
+      subject.expects(:tags).with(query).once
+        .returns([])
+      subject.available?(query)
+    end
+
+    test 'returns true if any matching image and tag is found' do
+      subject.stubs(:tags).with(query)
+        .returns([{ 'name' => "#{term}:latest" }])
+      subject.available?(query)
+    end
+
+    test 'returns false if none are found' do
+      subject.stubs(:tags).with(query)
+        .returns([])
+      subject.available?(query)
+    end
+  end
+end

data/test/units/registry_api_test.rb

@@ -1,17 +1,211 @@
 require 'test_plugin_helper'
 
 class RegistryApiTest < ActiveSupport::TestCase
-  test "initialize handles username password info correctly" do
-    uname = "tardis"
-    password = "boo"
-    url = "http://docker-who.gov"
-    reg = Service::RegistryApi.new(:url => url,
-                                   :user => uname,
-                                   :password => password)
-    assert reg.config[:url].include?(uname)
-    assert reg.config[:url].include?(password)
-
-    reg = Service::RegistryApi.new(:url => url)
-    assert_equal url, reg.config[:url]
+  let(:url) { 'http://dockerregistry.com:5000' }
+  subject { Service::RegistryApi.new(url: url) }
+
+  describe '#connection' do
+    test 'returns a Docker::Connection' do
+      assert_equal Docker::Connection, subject.connection.class
+    end
+
+    test 'the connection has the same url' do
+      assert_equal url, subject.connection.url
+    end
+
+    context 'authentication is set' do
+      let(:user) { 'username' }
+      let(:password) { 'secretpassword' }
+
+      subject do
+        Service::RegistryApi.new(
+          :url => url,
+          :password => password,
+          :user => user
+        )
+      end
+
+      test 'it sets the same user and password' do
+        assert_equal user, subject.connection.options[:user]
+        assert_equal password, subject.connection.options[:password]
+      end
+    end
+  end
+
+  describe '#get' do
+    let(:path) { '/v1/search' }
+    let(:json) { '{}' }
+
+    test 'calls get on #connection' do
+      subject.connection
+             .expects(:get).at_least_once
+             .returns(json)
+
+      subject.get(path)
+    end
+
+    test 'returns a parsed json' do
+      subject.connection.stubs(:get).returns(json)
+      assert_equal JSON.parse(json), subject.get(path)
+    end
+
+    # Docker::Connection is used and meant for the Docker,
+    # not the Registry API therefore it is required
+    # to override the path via options
+    test 'sets the path as an option not param for Docker::Connection#get' do
+      subject.connection.stubs(:get) do |path_param, _, options|
+        refute_equal path, path_param
+        assert_equal path, options[:path]
+      end.returns(json)
+
+      subject.get(path)
+    end
+
+    # Docker Hub will return a 503 when a 'Host' header includes a port.
+    # Omitting default ports (an Excon option) solves the issue
+    test 'sets omit_default_port to true' do
+      subject.connection.stubs(:get) do |_, _, options|
+        assert options[:omit_default_port]
+      end.returns(json)
+
+      subject.get(path)
+    end
+
+    test 'returns the response raw body if it is not JSON' do
+      response = 'This is not JSON'
+      subject.connection.stubs(:get)
+             .returns(response)
+      assert_equal response, subject.get('/v1/')
+    end
+  end
+
+  describe '#search' do
+    let(:path) { '/v1/search' }
+    let(:query) { 'centos' }
+
+    test "calls #get with path and query" do
+      subject.expects(:get).with(path, q: query) do |path_param, params|
+        assert_equal path, path_param
+        assert_equal query, params[:q]
+      end.returns({})
+
+      subject.search(query)
+    end
+
+    test "falls back to #catalog if #get fails" do
+      subject.expects(:catalog).with(query)
+
+      subject.expects(:get).with(path, q: query)
+             .raises('Error')
+
+      subject.search(query)
+    end
+  end
+
+  describe '#catalog' do
+    let(:path) { '/v2/_catalog' }
+    let(:query) { 'centos' }
+    let(:catalog) { { 'repositories' => ['centos', 'fedora'] } }
+
+    setup do
+      subject.stubs(:get).returns(catalog)
+    end
+
+    test "calls #get with path" do
+      subject.expects(:get).with(path)
+             .returns(catalog)
+
+      subject.catalog(query)
+    end
+
+    test 'returns {"name" => value} pairs' do
+      result = subject.catalog(query)
+      assert_equal({ "name" => query }, result.first)
+    end
+
+    test 'only give back matching results' do
+      result = subject.catalog('fedora')
+      assert_match(/^fedora/, result.first['name'])
+    end
+  end
+
+  describe '#tags' do
+    let(:query) { 'alpine' }
+    let(:path) { "/v1/repositories/#{query}/tags" }
+
+    test "calls #get with path" do
+      subject.expects(:get).with(path)
+      subject.tags(query)
+    end
+
+    test "falls back to #tags_v2 if #get fails" do
+      subject.expects(:get).with(path)
+             .raises('Error')
+
+      subject.expects(:tags_v2).with(query)
+      subject.tags(query)
+    end
+
+    # https://registry.access.redhat.com returns a hash not an array
+    test 'handles a hash response correctly' do
+      tags_hash = {
+        "7.0-21" => "e1f5733f050b2488a17b7630cb038bfbea8b7bdfa9bdfb99e63a33117e28d02f",
+        "7.0-23" => "bef54b8f8a2fdd221734f1da404d4c0a7d07ee9169b1443a338ab54236c8c91a",
+        "7.0-27" => "8e6704f39a3d4a0c82ec7262ad683a9d1d9a281e3c1ebbb64c045b9af39b3940"
+      }
+      subject.expects(:get).with(path)
+             .returns(tags_hash)
+      assert_equal '7.0-21', subject.tags(query).first['name']
+    end
+  end
+
+  describe '#tags for API v2' do
+    let(:query) { 'debian' }
+    let(:v1_path) { "/v1/repositories/#{query}/tags" }
+    let(:path) { "/v2/#{query}/tags/list" }
+    let(:tags) { { 'tags' => ['jessy', 'woody'] } }
+
+    setup do
+      subject.stubs(:get).with(v1_path)
+             .raises('404 Not found')
+    end
+
+    test 'calls #get with path' do
+      subject.expects(:get).with(path)
+             .returns(tags)
+      subject.tags(query)
+    end
+
+    test 'returns {"name" => value } pairs ' do
+      subject.stubs(:get).with(path).returns(tags)
+      result = subject.tags(query)
+      assert_equal tags['tags'].first, result.first['name']
+    end
+  end
+
+  describe '#ok?' do
+    test 'calls the API via #get with /v1/' do
+      subject.connection.expects(:get)
+             .with('/', nil, Service::RegistryApi::DEFAULTS[:connection].merge(path: '/v1/'))
+             .returns('Docker Registry API')
+      assert subject.ok?
+    end
+
+    test 'calls #get with /v2/ if /v1/fails' do
+      subject.stubs(:get).with('/v1/')
+             .raises('404 page not found')
+      subject.expects(:get).with('/v2/')
+             .returns({})
+      assert subject.ok?
+    end
+  end
+
+  describe '.docker_hub' do
+    subject { Service::RegistryApi }
+
+    test 'returns an instance for Docker Hub' do
+      result = subject.docker_hub
+      assert_equal Service::RegistryApi::DOCKER_HUB, result.url
+    end
   end
 end