artifactory 2.8.2 → 3.0.0

data/spec/unit/resources/plugin_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Resource::Plugin do
-    let(:client) { double(:client) }
-
-    before(:each) do
-      allow(Artifactory).to receive(:client).and_return(client)
-      allow(client).to receive(:get).and_return(response) if defined?(response)
-    end
-
-    describe ".all" do
-      let(:response) { %w{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(%w{a b c})
-      end
-    end
-  end
-end

data/spec/unit/resources/repository_spec.rb

@@ -1,217 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Resource::Repository do
-    let(:client) { double(:client) }
-
-    before(:each) do
-      allow(Artifactory).to receive(:client).and_return(client)
-      allow(client).to receive(:get).and_return(response) if defined?(response)
-    end
-
-    describe ".all" do
-      let(:response) do
-        [
-          { "key" => "a" },
-          { "key" => "b" },
-          { "key" => "c" },
-        ]
-      end
-      before do
-        allow(described_class).to receive(:find).with("a", client: client).and_return("a")
-        allow(described_class).to receive(:find).with("b", client: client).and_return("b")
-        allow(described_class).to receive(:find).with("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(%w{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("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"              => "",
-          "enableNuGetSupport"           => false,
-          "enableGemsSupport"            => false,
-          "checksumPolicyType"           => "server-generated-checksums",
-          "handleReleases"               => true,
-          "handleSnapshots"              => false,
-          "maxUniqueSnapshots"           => 10,
-          "snapshotVersionBehavior"      => "unique",
-          "suppressPomConsistencyChecks" => true,
-          "blackedOut"                   => false,
-          "propertySets"                 => ["artifactory"],
-          "archiveBrowsingEnabled"       => false,
-          "calculateYumMetadata"         => false,
-          "yumRootDepth"                 => 3,
-          "rclass"                       => "local",
-          "url"                          => "someurl",
-        }
-      end
-
-      it "creates a new instance" do
-        instance = described_class.from_hash(hash)
-        expect(instance.blacked_out).to be_falsey
-        expect(instance.description).to eq("Local repository for in-house libraries")
-        expect(instance.checksum_policy_type).to eq("server-generated-checksums")
-        expect(instance.excludes_pattern).to eq("")
-        expect(instance.handle_releases).to be_truthy
-        expect(instance.handle_snapshots).to be_falsey
-        expect(instance.includes_pattern).to eq("**/*")
-        expect(instance.key).to eq("libs-release-local")
-        expect(instance.max_unique_snapshots).to eq(10)
-        expect(instance.notes).to eq("")
-        expect(instance.package_type).to eq("generic")
-        expect(instance.property_sets).to eq(["artifactory"])
-        expect(instance.rclass).to eq("local")
-        expect(instance.repo_layout_ref).to eq("simple-default")
-        expect(instance.snapshot_version_behavior).to eq("unique")
-        expect(instance.suppress_pom_consistency_checks).to be_truthy
-        expect(instance.url).to eq("someurl")
-        expect(instance.yum_root_depth).to eq(3)
-        expect(instance.calculate_yum_metadata).to eq(false)
-      end
-    end
-
-    describe "#save" do
-      let(:client) { double }
-      before do
-        subject.client = client
-        subject.key = "libs-release-local"
-      end
-
-      context "when the repository is new" do
-        before do
-          allow(described_class).to receive(:find).with(subject.key, client: client).and_return(nil)
-        end
-
-        it "PUTS the file to the server" do
-          expect(client).to receive(:put).with("/api/repositories/#{subject.key}", kind_of(String), kind_of(Hash))
-          subject.save
-        end
-      end
-
-      context "when the repository exists" do
-        before do
-          allow(described_class).to receive(:find).with(subject.key, client: client).and_return({ key: subject.key })
-        end
-
-        it "POSTS the file to the server" do
-          expect(client).to receive(:post).with("/api/repositories/#{subject.key}", kind_of(String), kind_of(Hash))
-          subject.save
-        end
-      end
-    end
-
-    describe "#upload" do
-      let(:client) { double(put: {}) }
-      let(:file) { double(File) }
-      let(:path) { "/fake/path" }
-      before do
-        subject.client = client
-        subject.key    = "libs-release-local"
-        allow(File).to receive(:new).with(/\A(\w:)?#{path}\z/).and_return(file)
-      end
-
-      context "when the artifact is a file path" do
-        it "PUTs the file at the path to the server" do
-          expect(client).to receive(:put).with("libs-release-local/remote/path", file, {})
-
-          subject.upload(path, "/remote/path")
-        end
-      end
-
-      context "when matrix properties are given" do
-        it "converts the hash into matrix properties" do
-          expect(client).to receive(:put).with("libs-release-local;branch=master;user=Seth+Vargo%2B1/remote/path", file, {})
-
-          subject.upload(path, "/remote/path",
-            branch: "master",
-            user: "Seth Vargo+1"
-          )
-        end
-
-        it "converts the hash into matrix properties" do
-          expect(client).to receive(:put).with("libs-release-local;branch=master;user=Seth/remote/path", file, {})
-
-          subject.upload(path, "/remote/path",
-            branch: "master",
-            user: "Seth"
-          )
-        end
-
-        it 'converts spaces to "+" characters' do
-          expect(client).to receive(:put).with("libs-release-local;user=Seth+Vargo/remote/path", file, {})
-
-          subject.upload(path, "/remote/path",
-            user: "Seth Vargo"
-          )
-        end
-
-        it 'converts "+" to "%2B"' do
-          expect(client).to receive(:put).with("libs-release-local;version=12.0.0-alpha.1%2B20140826080510.git.50.f5ff271/remote/path", file, {})
-
-          subject.upload(path, "/remote/path",
-            version: "12.0.0-alpha.1+20140826080510.git.50.f5ff271"
-          )
-        end
-      end
-
-      context "when custom headers are given" do
-        it "passes the headers to the client" do
-          headers = { "Content-Type" => "text/plain" }
-          expect(client).to receive(:put).with("libs-release-local/remote/path", file, headers)
-
-          subject.upload(path, "/remote/path", {}, headers)
-        end
-      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
-
-    describe "#upload_with_checksum" do
-      it "delecates to artifact" do
-        artifact = double("Artifact")
-        allow(Resource::Artifact).to receive(:new) { artifact }
-        subject.key = "libs-release-local"
-        expect(artifact).to receive(:upload_with_checksum).once
-        subject.upload_with_checksum("/local/path", "/remote/path", "checksum", { properties: :foobar })
-      end
-    end
-
-    describe "#upload_from_archive" do
-      it "delecates to artifact" do
-        artifact = double("Artifact")
-        allow(Resource::Artifact).to receive(:new) { artifact }
-        subject.key = "libs-release-local"
-        expect(artifact).to receive(:upload_from_archive).once
-        subject.upload_from_archive("/local/path", "/remote/path", { properties: :foobar })
-      end
-    end
-  end
-end

data/spec/unit/resources/system_spec.rb

@@ -1,90 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Resource::System do
-    let(:client) { double(:client) }
-
-    before(:each) do
-      allow(Artifactory).to receive(:client).and_return(client)
-      allow(client).to receive(: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_truthy
-        end
-      end
-
-      context "when the system is not running" do
-        it "returns false" do
-          allow(client).to receive(:get)
-            .and_raise(Error::ConnectionError.new(Artifactory.endpoint))
-          expect(described_class.ping).to be_falsey
-        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 { allow(client).to receive(:post).and_return(response) }
-
-      it "posts /api/system/configuration" do
-        headers = { "Content-Type" => "application/xml" }
-        expect(client).to receive(:post).with("/api/system/configuration", xml, headers).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

data/spec/unit/resources/url_base_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Resource::URLBase do
-    let(:client) { double(:client) }
-
-    before(:each) do
-      allow(Artifactory).to receive(:client).and_return(client)
-      allow(client).to receive(:get).and_return(response) if defined?(response)
-    end
-
-    describe ".all" do
-      doc = <<-XML
-        <config>
-          <urlBase>http://33.33.33.20/artifactory</urlBase>
-        </config>
-      XML
-      let(:xml) do
-        REXML::Document.new(doc)
-      end
-
-      before do
-        allow(Resource::System).to receive(:configuration).and_return(xml)
-      end
-
-      it "returns the url bases" do
-        expect(described_class.all).to be_a(Array)
-        expect(described_class.all.first).to be_a(described_class)
-        expect(described_class.all.first.url_base).to eq("http://33.33.33.20/artifactory")
-      end
-    end
-
-    describe ".find" do
-      doc = <<-XML
-        <config>
-          <urlBase>http://proxyserver/artifactory</urlBase>
-        </config>
-      XML
-      let(:xml) do
-        REXML::Document.new(doc)
-      end
-
-      before do
-        allow(Resource::System).to receive(:configuration).and_return(xml)
-      end
-
-      it "returns the found urlBase" do
-        expect(described_class.find("http://proxyserver/artifactory")).to be_a(described_class)
-        expect(described_class.find("http://proxyserver/artifactory").url_base).to eq("http://proxyserver/artifactory")
-      end
-    end
-  end
-end

data/spec/unit/resources/user_spec.rb

@@ -1,115 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Resource::User do
-    let(:client) { double(:client) }
-    let(:endpoint_host) { "http://33.33.33.11" }
-    let(:endpoint) { "#{endpoint_host}/" }
-
-    before(:each) do
-      allow(Artifactory).to receive(:client).and_return(client)
-      allow(client).to receive(:get).and_return(response) if defined?(response)
-    end
-
-    describe ".all" do
-      let(:response) do
-        [
-          { "uri" => "a" },
-          { "uri" => "b" },
-          { "uri" => "c" },
-        ]
-      end
-      before do
-        allow(described_class).to receive(:from_url).with("a", client: client).and_return("a")
-        allow(described_class).to receive(:from_url).with("b", client: client).and_return("b")
-        allow(described_class).to receive(:from_url).with("c", client: client).and_return("c")
-      end
-
-      it "gets /api/security/users" do
-        expect(client).to receive(:get).with("/api/security/users").once
-        described_class.all
-      end
-
-      it "returns the users" do
-        expect(described_class.all).to eq(%w{a b c})
-      end
-    end
-
-    describe ".find" do
-      let(:response) { {} }
-
-      it 'gets /api/repositories/#{name}' do
-        expect(client).to receive(:get).with("/api/security/users/readers").once
-        described_class.find("readers")
-      end
-    end
-
-    describe ".from_url" do
-      let(:response) { {} }
-
-      it "constructs a new instance from the result" do
-        expect(client).to receive(:endpoint).and_return(endpoint)
-        expect(described_class).to receive(:from_hash).once
-        described_class.from_url("/api/security/users/readers")
-      end
-    end
-
-    describe ".from_hash" do
-      let(:hash) do
-        {
-          "admin"                    => false,
-          "email"                    => "admin@example.com",
-          "groups"                   => ["admin"],
-          "internalPasswordDisabled" => true,
-          "lastLoggedIn"             => nil,
-          "name"                     => "admin",
-          "profileUpdatable"         => true,
-          "realm"                    => "artifactory",
-        }
-      end
-
-      it "creates a new instance" do
-        instance = described_class.from_hash(hash)
-        expect(instance.admin).to be_falsey
-        expect(instance.email).to eq("admin@example.com")
-        expect(instance.groups).to eq(["admin"])
-        expect(instance.internal_password_disabled).to be_truthy
-        expect(instance.last_logged_in).to be_nil
-        expect(instance.name).to eq("admin")
-        expect(instance.password).to be_nil
-        expect(instance.profile_updatable).to be_truthy
-        expect(instance.realm).to eq("artifactory")
-      end
-    end
-
-    describe "#save" do
-      let(:client) { double }
-      before do
-        subject.client = client
-        subject.name = "schisamo"
-      end
-
-      context "when the user is new" do
-        before do
-          allow(described_class).to receive(:find).with(subject.name, client: client).and_return(nil)
-        end
-
-        it "PUTS the user to the server" do
-          expect(client).to receive(:put).with("/api/security/users/#{subject.name}", kind_of(String), kind_of(Hash))
-          subject.save
-        end
-      end
-
-      context "when the user exists" do
-        before do
-          allow(described_class).to receive(:find).with(subject.name, client: client).and_return({ name: subject.name })
-        end
-
-        it "POSTS the user to the server" do
-          expect(client).to receive(:post).with("/api/security/users/#{subject.name}", kind_of(String), kind_of(Hash))
-          subject.save
-        end
-      end
-    end
-  end
-end