artifactory 0.0.1 → 1.0.0

data/spec/unit/resources/base_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module Artifactory
+  describe Resource::Base do
+    describe '.attribute' do
+      before { described_class.attribute(:bacon) }
+
+      it 'defines an accessor method' do
+        expect(subject).to respond_to(:bacon)
+      end
+
+      it 'defines a setter method' do
+        expect(subject).to respond_to(:bacon=)
+      end
+
+      it 'defines a boolean method' do
+        expect(subject).to respond_to(:bacon?)
+      end
+    end
+
+    describe '.extract_client!' do
+      context 'when the :client key is present' do
+        let(:client) { double }
+        let(:options) { { client: client } }
+
+        it 'extracts the client' do
+          result = described_class.extract_client!(options)
+          expect(result).to be(client)
+        end
+
+        it 'removes the key from the hash' do
+          described_class.extract_client!(options)
+          expect(options).to_not have_key(:client)
+        end
+      end
+
+      context 'when the :client key is not present' do
+        let(:client) { double }
+        before { Artifactory.stub(:client).and_return(client) }
+
+        it 'uses Artifactory.client' do
+          expect(described_class.extract_client!({})).to be(client)
+        end
+      end
+    end
+
+    describe '.format_repos!' do
+      context 'when the :repos key is present' do
+        it 'joins an array' do
+          options = { repos: ['bacon', 'bits'] }
+          described_class.format_repos!(options)
+          expect(options[:repos]).to eq('bacon,bits')
+        end
+
+        it 'accepts a single repository' do
+          options = { repos: 'bacon' }
+          described_class.format_repos!(options)
+          expect(options[:repos]).to eq('bacon')
+        end
+      end
+
+      context 'when the :repos key is not present' do
+        it 'does not modify the hash' do
+          options = {}
+          described_class.format_repos!(options)
+          expect(options).to eq(options)
+        end
+      end
+
+      context 'when the :repos key is empty' do
+        it 'does not modify the hash' do
+          options = { repos: [] }
+          described_class.format_repos!(options)
+          expect(options).to eq(options)
+        end
+      end
+
+      describe '.url_safe' do
+        let(:string) { double(to_s: 'string') }
+
+        it 'delegates to URI.escape' do
+          expect(URI).to receive(:escape).once
+          described_class.url_safe(string)
+        end
+
+        it 'converts the value to a string' do
+          expect(string).to receive(:to_s).once
+          described_class.url_safe(string)
+        end
+      end
+    end
+
+    describe '#client' do
+      it 'defines a :client method' do
+        expect(subject).to respond_to(:client)
+      end
+
+      it 'defaults to the Artifactory.client' do
+        client = double
+        Artifactory.stub(:client).and_return(client)
+
+        expect(subject.client).to be(client)
+      end
+    end
+
+    describe '#extract_client!' do
+      it 'delegates to the class method' do
+        expect(described_class).to receive(:extract_client!).once
+        subject.extract_client!({})
+      end
+    end
+
+    describe '#format_repos!' do
+      it 'delegates to the class method' do
+        expect(described_class).to receive(:format_repos!).once
+        subject.format_repos!({})
+      end
+    end
+
+    describe '#url_safe' do
+      it 'delegates to the class method' do
+        expect(described_class).to receive(:url_safe).once
+        subject.url_safe('string')
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the name of the class' do
+        expect(subject.to_s).to eq('#<Artifactory::Resource::Base>')
+      end
+    end
+
+    describe '#inspect' do
+      it 'includes all the instance variables' do
+        subject.instance_variable_set(:@foo, 'bar')
+        expect(subject.inspect).to eq(%q|#<Artifactory::Resource::Base foo: "bar">|)
+      end
+    end
+  end
+end

data/spec/unit/resources/build_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Artifactory
+  describe Resource::Build do
+    let(:client) { double(:client) }
+
+    before(:each) do
+      Artifactory.stub(:client).and_return(client)
+      client.stub(:get).and_return(response) if defined?(response)
+    end
+
+    describe '.all' do
+      let(:response) { ['a', 'b', 'c'] }
+
+      it 'gets /api/build' do
+        expect(client).to receive(:get).with('/api/build').once
+        described_class.all
+      end
+
+      context 'when there are builds' do
+        it 'returns the builds' do
+          expect(described_class.all).to eq(['a', 'b', 'c'])
+        end
+      end
+
+      context 'when the system has no builds' do
+        it 'returns an empty array' do
+          client.stub(:get).and_raise(Error::NotFound)
+          expect(described_class.all).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/unit/resources/plugin_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Artifactory
+  describe Resource::Plugin do
+    let(:client) { double(:client) }
+
+    before(:each) do
+      Artifactory.stub(:client).and_return(client)
+      client.stub(:get).and_return(response) if defined?(response)
+    end
+
+    describe '.all' do
+      let(:response) { ['a', 'b', 'c'] }
+
+      it 'gets /api/plugins' do
+        expect(client).to receive(:get).with('/api/plugins').once
+        described_class.all
+      end
+
+      it 'returns the plugins' do
+        expect(described_class.all).to eq(['a', 'b', 'c'])
+      end
+    end
+  end
+end

data/spec/unit/resources/repository_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+module Artifactory
+  describe Resource::Repository do
+    let(:client) { double(:client) }
+
+    before(:each) do
+      Artifactory.stub(:client).and_return(client)
+      client.stub(:get).and_return(response) if defined?(response)
+    end
+
+    describe '.all' do
+      let(:response) do
+        [
+          { 'key' => 'a' },
+          { 'key' => 'b' },
+          { 'key' => 'c' },
+        ]
+      end
+      before do
+        described_class.stub(:find).with(name: 'a', client: client).and_return('a')
+        described_class.stub(:find).with(name: 'b', client: client).and_return('b')
+        described_class.stub(:find).with(name: 'c', client: client).and_return('c')
+      end
+
+      it 'gets /api/repositories' do
+        expect(client).to receive(:get).with('/api/repositories').once
+        described_class.all
+      end
+
+      it 'returns the repositories' do
+        expect(described_class.all).to eq(['a', 'b', 'c'])
+      end
+    end
+
+    describe '.find' do
+      let(:response) { {} }
+
+      it 'gets /api/repositories/#{name}' do
+        expect(client).to receive(:get).with('/api/repositories/libs-release-local').once
+        described_class.find(name: 'libs-release-local')
+      end
+    end
+
+    describe '.from_hash' do
+      let(:hash) do
+        {
+          'key'                          => 'libs-release-local',
+          'description'                  => 'Local repository for in-house libraries',
+          'notes'                        => '',
+          'includesPattern'              => '**/*',
+          'excludesPattern'              => '',
+          'repoLayoutRef'                => 'maven-2-default',
+          'enableNuGetSupport'           => false,
+          'enableGemsSupport'            => false,
+          'checksumPolicyType'           => 'client-checksums',
+          'handleReleases'               => true,
+          'handleSnapshots'              => false,
+          'maxUniqueSnapshots'           => 0,
+          'snapshotVersionBehavior'      => 'unique',
+          'suppressPomConsistencyChecks' => false,
+          'blackedOut'                   => false,
+          'propertySets'                 => ['artifactory'],
+          'archiveBrowsingEnabled'       => false,
+          'calculateYumMetadata'         => false,
+          'yumRootDepth'                 => 0,
+          'rclass'                       => 'local',
+        }
+      end
+
+      it 'creates a new instnace' do
+        instance = described_class.from_hash(hash)
+        expect(instance.blacked_out).to be_false
+        expect(instance.description).to eq('Local repository for in-house libraries')
+        expect(instance.checksum_policy).to eq('client-checksums')
+        expect(instance.excludes_pattern).to eq('')
+        expect(instance.handle_releases).to be_true
+        expect(instance.handle_snapshots).to be_false
+        expect(instance.includes_pattern).to eq('**/*')
+        expect(instance.key).to eq('libs-release-local')
+        expect(instance.maximum_unique_snapshots).to eq(0)
+        expect(instance.notes).to eq('')
+        expect(instance.property_sets).to eq(['artifactory'])
+        expect(instance.snapshot_version_behavior).to eq('unique')
+        expect(instance.suppress_pom_checks).to be_false
+        expect(instance.type).to eq('local')
+      end
+    end
+
+    describe '#upload' do
+      let(:client) { double }
+      before do
+        subject.client = client
+        subject.key    = 'libs-release-local'
+      end
+
+      context 'when the artifact is a File' do
+        it 'PUTs the file to the server' do
+          file = double(:file, is_a?: true)
+          expect(client).to receive(:put).with('libs-release-local/remote/path', { file: file }, {})
+
+          subject.upload(file, '/remote/path')
+        end
+      end
+
+      context 'when the artifact is a file path' do
+        it 'PUTs the file at the path to the server' do
+          file = double(:file)
+          path = '/fake/path'
+          File.stub(:new).with('/fake/path').and_return(file)
+          expect(client).to receive(:put).with('libs-release-local/remote/path', { file: file }, {})
+
+          subject.upload(path, '/remote/path')
+        end
+      end
+
+      context 'when matrix properties are given' do
+        it 'converts the hash into matrix properties' do
+          file = double(:file, is_a?: true)
+          expect(client).to receive(:put).with('libs-release-local;branch=master;user=Seth%20Vargo/remote/path', { file: file }, {})
+
+          subject.upload(file, '/remote/path',
+            branch: 'master',
+            user: 'Seth Vargo',
+          )
+        end
+      end
+
+      context 'when custom headers are given' do
+        it 'passes the headers to the client' do
+          headers = { 'Content-Type' => 'text/plain' }
+          file = double(:file, is_a?: true)
+          expect(client).to receive(:put).with('libs-release-local/remote/path', { file: file }, headers)
+
+          subject.upload(file, '/remote/path', {}, headers)
+        end
+      end
+    end
+
+    describe '#upload_with_checksum' do
+      it 'delegates to #upload' do
+        expect(subject).to receive(:upload).with(
+          '/local/file',
+          '/remote/path',
+          { branch: 'master' },
+          {
+            'X-Checksum-Deploy' => true,
+            'X-Checksum-Sha1'   => 'ABCD1234',
+          },
+        )
+        subject.upload_with_checksum('/local/file', '/remote/path',
+          'ABCD1234',
+          { branch: 'master' },
+        )
+      end
+    end
+
+    describe '#upload_from_archive' do
+      it 'delegates to #upload' do
+        expect(subject).to receive(:upload).with(
+          '/local/file',
+          '/remote/path',
+          {},
+          {
+            'X-Explode-Archive' => true,
+          },
+        )
+        subject.upload_from_archive('/local/file', '/remote/path')
+      end
+    end
+
+    describe '#artifacts' do
+      before { subject.key = 'libs-release-local' }
+
+      it 'returns an artifact collection' do
+        expect(subject.artifacts).to be_a(Collection::Artifact)
+      end
+    end
+  end
+end

data/spec/unit/resources/system_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module Artifactory
+  describe Resource::System do
+    let(:client) { double(:client) }
+
+    before(:each) do
+      Artifactory.stub(:client).and_return(client)
+      client.stub(:get).and_return(response) if defined?(response)
+    end
+
+    describe '.info' do
+      let(:response) { 'This is the response...' }
+
+      it 'calls /api/system' do
+        expect(client).to receive(:get).with('/api/system').once
+        described_class.info
+      end
+
+      it 'returns the plan-text body' do
+        expect(described_class.info).to eq(response)
+      end
+    end
+
+    describe '.ping' do
+      let(:response) { '' }
+
+      it 'gets /api/system/ping' do
+        expect(client).to receive(:get).with('/api/system/ping').once
+        described_class.ping
+      end
+
+      context 'when the system is ok' do
+        it 'returns true' do
+          expect(described_class.ping).to be_true
+        end
+      end
+
+      context 'when the system is not running' do
+        it 'returns false' do
+          client.stub(:get).and_raise(Error::ConnectionError)
+          expect(described_class.ping).to be_false
+        end
+      end
+    end
+
+    describe '.configuration' do
+      let(:response) { '<config></config>' }
+
+      it 'gets /api/system/configuration' do
+        expect(client).to receive(:get).with('/api/system/configuration').once
+        described_class.configuration
+      end
+
+      it 'returns the xml' do
+        expect(described_class.configuration).to be_a(REXML::Document)
+      end
+    end
+
+    describe '.update_configuration' do
+      let(:xml) { double(:xml) }
+      let(:response) { double(body: '...') }
+      before { client.stub(:post).and_return(response) }
+
+      it 'posts /api/system/configuration' do
+        expect(client).to receive(:post).with('/api/system/configuration', xml).once
+        described_class.update_configuration(xml)
+      end
+
+      it 'returns the body of the response' do
+        expect(described_class.update_configuration(xml)).to eq(response)
+      end
+    end
+
+    describe '.version' do
+      let(:response) { double(json: { 'foo' => 'bar' }) }
+
+      it 'gets /api/system/version' do
+        expect(client).to receive(:get).with('/api/system/version').once
+        described_class.version
+      end
+
+      it 'returns the parsed JSON of the response' do
+        expect(described_class.version).to eq(response)
+      end
+    end
+  end
+end