artifactory 2.8.2 → 3.0.0

data/spec/support/api_server/status_endpoints.rb

@@ -1,11 +0,0 @@
-module Artifactory
-  module APIServer::StatusEndpoints
-    def self.registered(app)
-      app.get("/status/:code") { code.to_i }
-      app.post("/status/:code") { code.to_i }
-      app.patch("/status/:code") { code.to_i }
-      app.put("/status/:code") { code.to_i }
-      app.delete("/status/:code") { code.to_i }
-    end
-  end
-end

data/spec/support/api_server/system_endpoints.rb

@@ -1,104 +0,0 @@
-module Artifactory
-  module APIServer::SystemEndpoints
-    def self.registered(app)
-      app.get("/api/system") do
-        "This is some serious system info right here"
-      end
-
-      app.get("/api/system/ping") do
-        "OK"
-      end
-
-      app.get("/api/system/configuration") do
-        content_type "application/xml"
-        <<-EOH.gsub(/^ {10}/, "")
-          <?xml version='1.0' encoding='UTF-8' standalone='yes'?>
-          <config xsi:schemaLocation='http://www.jfrog.org/xsd/artifactory-v1_5_3.xsd'
-                  xmlns='http://artifactory.jfrog.org/xsd/1.5.3'
-                  xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
-            <offlineMode>false</offlineMode>
-            <repoLayouts>
-              <repoLayout>
-                <name>maven-2-default</name>
-                <artifactPathPattern>[orgPath]/[module]/[baseRev](-[folderItegRev])/[module]-[baseRev](-[fileItegRev])(-[classifier]).[ext]</artifactPathPattern>
-                <distinctiveDescriptorPathPattern>true</distinctiveDescriptorPathPattern>
-                <descriptorPathPattern>[orgPath]/[module]/[baseRev](-[folderItegRev])/[module]-[baseRev](-[fileItegRev])(-[classifier]).pom</descriptorPathPattern>
-                <folderIntegrationRevisionRegExp>SNAPSHOT</folderIntegrationRevisionRegExp>
-                <fileIntegrationRevisionRegExp>SNAPSHOT|(?:(?:[0-9]{8}.[0-9]{6})-(?:[0-9]+))</fileIntegrationRevisionRegExp>
-              </repoLayout>
-              <repoLayout>
-                <name>gradle-default</name>
-                <artifactPathPattern>[orgPath]/[module]/[baseRev](-[folderItegRev])/[module]-[baseRev](-[fileItegRev])(-[classifier]).[ext]</artifactPathPattern>
-                <distinctiveDescriptorPathPattern>true</distinctiveDescriptorPathPattern>
-                <descriptorPathPattern>[orgPath]/[module]/[baseRev](-[folderItegRev])/[module]-[baseRev](-[fileItegRev])(-[classifier]).pom</descriptorPathPattern>
-                <folderIntegrationRevisionRegExp>SNAPSHOT</folderIntegrationRevisionRegExp>
-                <fileIntegrationRevisionRegExp>SNAPSHOT|(?:(?:[0-9]{8}.[0-9]{6})-(?:[0-9]+))</fileIntegrationRevisionRegExp>
-              </repoLayout>
-            </repoLayouts>
-            <urlBase>http://33.33.33.20/artifactory</urlBase>
-            <mailServer>
-              <enabled>true</enabled>
-              <host>smtp.gmail.com</host>
-              <port>25</port>
-              <username>us@example.com</username>
-              <password>ihopethisisnotyourpassword</password>
-              <from>artifactory@example.com</from>
-              <subjectPrefix>[Artifactory]</subjectPrefix>
-              <tls>true</tls>
-              <ssl>false</ssl>
-              <artifactoryUrl>http://33.33.33.20/artifactory</artifactoryUrl>
-            </mailServer>
-            <security>
-              <ldapSettings>
-                <ldapSetting>
-                  <key>example-ldap</key>
-                  <enabled>true</enabled>
-                  <ldapUrl>ldap://localhost/DC=examplecorp,DC=com</ldapUrl>
-                  <search>
-                    <searchFilter>sAMAccountName={0}</searchFilter>
-                    <searchBase>OU=Domain Users</searchBase>
-                    <searchSubTree>true</searchSubTree>
-                    <managerDn>CN=ldapbind,OU=Employees,OU=Domain Users,DC=examplecorp,DC=com</managerDn>
-                    <managerPassword>ldappassword</managerPassword>
-                  </search>
-                  <autoCreateUser>false</autoCreateUser>
-                  <emailAttribute>mail</emailAttribute>
-                </ldapSetting>
-              </ldapSettings>
-            </security>
-            <backups>
-              <backup>
-                <key>backup-daily</key>
-                <enabled>true</enabled>
-                <cronExp>0 0 2 ? * MON-FRI</cronExp>
-                <retentionPeriodHours>0</retentionPeriodHours>
-                <createArchive>false</createArchive>
-                <excludedRepositories/>
-                <sendMailOnError>true</sendMailOnError>
-                <excludeBuilds>false</excludeBuilds>
-             </backup>
-           </backups>
-         </config>
-        EOH
-      end
-
-      app.post("/api/system/configuration") do
-        # Just echo the response we got back, since it seems that's what a real
-        # Artifactory server does...
-        request.body.read
-      end
-
-      app.get("/api/system/version") do
-        content_type "application/vnd.org.jfrog.artifactory.system.Version+json"
-        JSON.generate({
-          "version" => "3.1.0",
-          "revision" => "30062",
-          "addons" => %w{
-ldap
-license
-yum},
-        })
-      end
-    end
-  end
-end

data/spec/support/api_server/user_endpoints.rb

@@ -1,59 +0,0 @@
-module Artifactory
-  module APIServer::UserEndpoints
-    def self.registered(app)
-      app.get("/api/security/users") do
-        content_type "application/vnd.org.jfrog.artifactory.security.Users+json"
-        JSON.fast_generate([
-          {
-            "name" => "sethvargo",
-            "uri"  => server_url.join("/api/security/users/sethvargo"),
-          },
-          {
-            "name" => "yzl",
-            "uri"  => server_url.join("/api/security/users/yzl"),
-          },
-        ])
-      end
-
-      app.get("/api/security/users/sethvargo") do
-        content_type "application/vnd.org.jfrog.artifactory.security.User+json"
-        JSON.fast_generate(
-          "admin"                    => false,
-          "email"                    => "sethvargo@gmail.com",
-          "groups"                   => ["admin"],
-          "internalPasswordDisabled" => true,
-          "lastLoggedIn"             => nil,
-          "name"                     => "sethvargo",
-          "profileUpdatable"         => true,
-          "realm"                    => "artifactory"
-        )
-      end
-
-      app.get("/api/security/users/yzl") do
-        content_type "application/vnd.org.jfrog.artifactory.security.User+json"
-        JSON.fast_generate(
-          "admin"                    => true,
-          "email"                    => "yvonne@getchef.com",
-          "groups"                   => ["admin"],
-          "internalPasswordDisabled" => true,
-          "lastLoggedIn"             => nil,
-          "name"                     => "yzl",
-          "profileUpdatable"         => true,
-          "realm"                    => "crowd"
-        )
-      end
-
-      app.put("/api/security/users/:name") do
-        return 415 unless request.content_type == "application/vnd.org.jfrog.artifactory.security.User+json"
-
-        # Attempt to parse the response; if this succeeds, all is well...
-        JSON.parse(request.body.read)
-        nil
-      end
-
-      app.delete("/api/security/users/:name") do
-        nil
-      end
-    end
-  end
-end

data/spec/unit/artifactory_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-
-describe Artifactory do
-  it "sets the default values" do
-    Artifactory::Configurable.keys.each do |key|
-      value = Artifactory::Defaults.send(key)
-      expect(Artifactory.instance_variable_get(:"@#{key}")).to eq(value)
-    end
-  end
-
-  describe ".client" do
-    it "creates an Artifactory::Client" do
-      expect(Artifactory.client).to be_a(Artifactory::Client)
-    end
-
-    it "caches the client when the same options are passed" do
-      expect(Artifactory.client).to eq(Artifactory.client)
-    end
-
-    it "returns a fresh client when options are not the same" do
-      original_client = Artifactory.client
-
-      # Change settings
-      Artifactory.username = "admin"
-      new_client = Artifactory.client
-
-      # Get it one more tmie
-      current_client = Artifactory.client
-
-      expect(original_client).to_not eq(new_client)
-      expect(new_client).to eq(current_client)
-    end
-  end
-
-  describe ".configure" do
-    Artifactory::Configurable.keys.each do |key|
-      it "sets the #{key.to_s.tr('_', ' ')}" do
-        Artifactory.configure do |config|
-          config.send("#{key}=", key)
-        end
-
-        expect(Artifactory.instance_variable_get(:"@#{key}")).to eq(key)
-      end
-    end
-  end
-
-  describe ".method_missing" do
-    context "when the client responds to the method" do
-      let(:client) { double(:client) }
-      before { allow(Artifactory).to receive(:client).and_return(client) }
-
-      it "delegates the method to the client" do
-        allow(client).to receive(:bacon).and_return("awesome")
-        expect { Artifactory.bacon }.to_not raise_error
-      end
-    end
-
-    context "when the client does not respond to the method" do
-      it "calls super" do
-        expect { Artifactory.bacon }.to raise_error(NoMethodError)
-      end
-    end
-  end
-
-  describe ".respond_to_missing?" do
-    let(:client) { double(:client) }
-    before { allow(Artifactory).to receive(:client).and_return(client) }
-
-    it "delegates to the client" do
-      expect { Artifactory.respond_to_missing?(:foo) }.to_not raise_error
-    end
-  end
-end

data/spec/unit/client_spec.rb

@@ -1,132 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Client do
-    let(:client) { subject }
-
-    context "configuration" do
-      it "is a configurable object" do
-        expect(client).to be_a(Configurable)
-      end
-
-      it "users the default configuration" do
-        Defaults.options.each do |key, value|
-          expect(client.send(key)).to eq(value)
-        end
-      end
-
-      it "uses the values in the initializer" do
-        client = described_class.new(username: "admin")
-        expect(client.username).to eq("admin")
-      end
-
-      it "can be modified after initialization" do
-        expect(client.username).to eq(Defaults.username)
-        client.username = "admin"
-        expect(client.username).to eq("admin")
-      end
-    end
-
-    describe ".proxy" do
-      before { described_class.proxy(Resource::Artifact) }
-
-      it "defines a new method" do
-        expect(described_class).to be_method_defined(:artifact_search)
-      end
-
-      it "delegates to the class, injecting the client" do
-        allow(Resource::Artifact).to receive(:search)
-        expect(Resource::Artifact).to receive(:search).with(client: subject)
-        subject.artifact_search
-      end
-    end
-
-    describe "#get" do
-      it "delegates to the #request method" do
-        expect(subject).to receive(:request).with(:get, "/foo", {}, {})
-        subject.get("/foo")
-      end
-
-      context "called with a block" do
-        it "yields the response in chunks" do
-          expect(subject).to receive(:request).with(:get, "/foo", {}, {}) { |&block| block.call("Chunked Body") }
-          expect { |chunk| subject.get("/foo", &chunk) }.to yield_with_args("Chunked Body")
-        end
-      end
-    end
-
-    describe "#post" do
-      let(:data) { double }
-
-      it "delegates to the #request method" do
-        expect(subject).to receive(:request).with(:post, "/foo", data, {})
-        subject.post("/foo", data)
-      end
-    end
-
-    describe "#put" do
-      let(:data) { double }
-
-      it "delegates to the #request method" do
-        expect(subject).to receive(:request).with(:put, "/foo", data, {})
-        subject.put("/foo", data)
-      end
-    end
-
-    describe "#patch" do
-      let(:data) { double }
-
-      it "delegates to the #request method" do
-        expect(subject).to receive(:request).with(:patch, "/foo", data, {})
-        subject.patch("/foo", data)
-      end
-    end
-
-    describe "#delete" do
-      it "delegates to the #request method" do
-        expect(subject).to receive(:request).with(:delete, "/foo", {}, {})
-        subject.delete("/foo")
-      end
-    end
-
-    describe "#request" do
-      context "when the response is a 400" do
-        before { stub_request(:get, /.+/).to_return(status: 5000, body: "No!") }
-
-        it "raises an HTTPError error" do
-          expect { subject.request(:get, "/") }.to raise_error(Error::HTTPError)
-        end
-      end
-
-      context "called with a block" do
-        before { stub_request(:get, /.+/).to_return(status: 200, body: "Chunked Body") }
-
-        it "yields the response in chunks" do
-          subject.request(:get, "/foo") do |chunk|
-            expect(chunk).to eq("Chunked Body")
-          end
-        end
-      end
-
-      context "application/json response with an empty body" do
-        before { stub_request(:get, /.+/).to_return(status: 200, headers: { "Content-Type" => "application/json" }, body: "") }
-
-        it "should not raise an error" do
-          expect { subject.request(:get, "/foo") }.to_not raise_error(TypeError)
-        end
-      end
-    end
-
-    describe "#to_query_string" do
-      it 'converts spaces to "+" characters' do
-        params = { user: "Seth Chisamore" }
-        expect(subject.to_query_string(params)).to eq("user=Seth+Chisamore")
-      end
-
-      it 'converts "+" to "%2B"' do
-        params = { version: "12.0.0-alpha.1+20140826080510.git.50.f5ff271" }
-        expect(subject.to_query_string(params)).to eq("version=12.0.0-alpha.1%2B20140826080510.git.50.f5ff271")
-      end
-    end
-  end
-end

data/spec/unit/resources/artifact_spec.rb

@@ -1,608 +0,0 @@
-require "spec_helper"
-
-module Artifactory
-  describe Resource::Artifact 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 ".search" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/artifact" do
-        expect(client).to receive(:get).with("/api/search/artifact", {}).once
-        described_class.search
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/artifact",
-          name:  "name",
-          repos: "repo"
-        ).once
-        described_class.search(
-          name:  "name",
-          repos: "repo",
-          fizz:  "foo"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.search).to be_a(Array)
-      end
-    end
-
-    describe "#upload" do
-      let(:client)     { double(put: {}) }
-      let(:local_path) { "/local/path" }
-      let(:file)       { double(File) }
-
-      subject { described_class.new(client: client, local_path: local_path) }
-
-      before do
-        allow(File).to receive(:new).with(/\A(\w:)?#{local_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("libs-release-local", "/remote/path")
-        end
-      end
-
-      context "when the md5 is available" do
-        subject { described_class.new(client: client, local_path: local_path, checksums: { "md5" => "ABCDEF123456" } ) }
-
-        it "PUTs the file with the checksum headers set" do
-          expect(client).to receive(:put).with("libs-release-local/remote/path", file, { "X-Checksum-Md5" => "ABCDEF123456" } )
-          subject.upload("libs-release-local", "/remote/path")
-        end
-      end
-
-      context "when the sha1 is available" do
-        subject { described_class.new(client: client, local_path: local_path, checksums: { "sha1" => "SHA1" } ) }
-
-        it "PUTs the file with the checksum headers set" do
-          expect(client).to receive(:put).with("libs-release-local/remote/path", file, { "X-Checksum-Sha1" => "SHA1" } )
-          subject.upload("libs-release-local", "/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/remote/path", file, {})
-
-          subject.upload("libs-release-local", "/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("libs-release-local", "/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("libs-release-local", "/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("libs-release-local", "/remote/path", {}, headers)
-        end
-      end
-    end
-
-    describe "#upload_checksum" do
-      it "uploads checksum.sha1" do
-        value = "ABCD1234"
-
-        tempfile = double("Tempfile").as_null_object
-        expect(Tempfile).to receive(:new).with("checksum.sha1") { tempfile }
-        expect(tempfile).to receive(:write).with(value).once
-        expect(client).to receive(:put).with(
-            "libs-release-local/remote/path.sha1",
-            tempfile
-        )
-        subject.upload_checksum("libs-release-local", "/remote/path", "sha1", value)
-      end
-    end
-
-    describe "#upload_with_checksum" do
-      it "delegates to #upload" do
-        expect(subject).to receive(:upload).with(
-          "libs-release-local",
-          "/remote/path",
-          { branch: "master" },
-          {
-            "X-Checksum-Deploy" => true,
-            "X-Checksum-Sha1"   => "ABCD1234",
-          }
-        )
-        subject.upload_with_checksum("libs-release-local", "/remote/path", "ABCD1234",
-          { branch: "master" }
-        )
-      end
-    end
-
-    describe "#upload_from_archive" do
-      it "delegates to #upload" do
-        expect(subject).to receive(:upload).with(
-          "libs-release-local",
-          "/remote/path",
-          {},
-          { "X-Explode-Archive" => true }
-        )
-        subject.upload_from_archive("libs-release-local", "/remote/path")
-      end
-
-      it "receives empty response" do
-        file = double(File)
-        allow(File).to receive(:new).and_return( file )
-        expect(client).to receive(:put).with(
-            "libs-release-local/remote/path",
-            file,
-            { "X-Explode-Archive" => true }
-        )
-        subject.local_path = "/local/path"
-        subject.upload_from_archive("libs-release-local", "/remote/path")
-      end
-
-    end
-
-    describe ".gavc_search" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/gavc" do
-        expect(client).to receive(:get).with("/api/search/gavc", {}).once
-        described_class.gavc_search
-      end
-
-      it "renames the parameters" do
-        expect(client).to receive(:get).with("/api/search/gavc",
-          g: "group",
-          a: "name",
-          v: "version",
-          c: "classifier"
-        ).once
-        described_class.gavc_search(
-          group:      "group",
-          name:       "name",
-          version:    "version",
-          classifier: "classifier"
-        )
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/gavc",
-          g: "group",
-          a: "name"
-        ).once
-        described_class.gavc_search(
-          group: "group",
-          name: "name",
-          fizz: "foo"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.gavc_search).to be_a(Array)
-      end
-    end
-
-    describe ".property_search" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/prop" do
-        expect(client).to receive(:get).with("/api/search/prop", {}).once
-        described_class.property_search
-      end
-
-      it "passes all the parameters" do
-        expect(client).to receive(:get).with("/api/search/prop",
-          p1: "v1",
-          p2: "v2"
-        ).once
-        described_class.property_search(
-          p1: "v1",
-          p2: "v2"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.property_search).to be_a(Array)
-      end
-    end
-
-    describe ".checksum_search" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/checksum" do
-        expect(client).to receive(:get).with("/api/search/checksum", {}).once
-        described_class.checksum_search
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/checksum",
-          md5:  "MD5123",
-          sha1: "SHA456"
-        ).once
-        described_class.checksum_search(
-          md5:  "MD5123",
-          sha1: "SHA456",
-          fizz: "foo"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.checksum_search).to be_a(Array)
-      end
-    end
-
-    describe ".usage_search" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/usage" do
-        expect(client).to receive(:get).with("/api/search/usage", {}).once
-        described_class.usage_search
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/usage",
-          notUsedSince:  1414800000000,
-          createdBefore: 1414871200000
-        ).once
-        described_class.usage_search(
-          notUsedSince:  1414800000000,
-          createdBefore: 1414871200000,
-          fizz: "foo"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.usage_search).to be_a(Array)
-      end
-    end
-
-    describe ".creation_search" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/creation" do
-        expect(client).to receive(:get).with("/api/search/creation", {}).once
-        described_class.creation_search
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/creation",
-          from:  1414800000000,
-          to: 1414871200000
-        ).once
-        described_class.creation_search(
-          from:  1414800000000,
-          to: 1414871200000,
-          fizz: "foo"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.creation_search).to be_a(Array)
-      end
-    end
-
-    describe ".versions" do
-      let(:response) { { "results" => [] } }
-
-      it "calls /api/search/versions" do
-        expect(client).to receive(:get).with("/api/search/versions", {}).once
-        described_class.versions
-      end
-
-      it "renames the parameters" do
-        expect(client).to receive(:get).with("/api/search/versions",
-          g: "group",
-          a: "name",
-          v: "version"
-        ).once
-        described_class.versions(
-          group:      "group",
-          name:       "name",
-          version:    "version"
-        )
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/versions",
-          g: "group",
-          a: "name"
-        ).once
-        described_class.versions(
-          group: "group",
-          name: "name",
-          fizz: "foo"
-        )
-      end
-
-      it "returns an array of objects" do
-        expect(described_class.versions).to be_a(Array)
-      end
-
-      it "returns an empty array when the server responses with a 404" do
-        allow(client).to receive(:get).and_raise(Error::HTTPError.new("status" => 404))
-
-        result = described_class.versions
-        expect(result).to be_a(Array)
-        expect(result).to be_empty
-      end
-    end
-
-    describe ".latest_version" do
-      let(:response) { "1.2-SNAPSHOT" }
-
-      it "calls /api/search/latestVersion" do
-        expect(client).to receive(:get).with("/api/search/latestVersion", {}).once
-        described_class.latest_version
-      end
-
-      it "renames the parameters" do
-        expect(client).to receive(:get).with("/api/search/latestVersion",
-          g: "group",
-          a: "name",
-          v: "version"
-        ).once
-        described_class.latest_version(
-          group:      "group",
-          name:       "name",
-          version:    "version"
-        )
-      end
-
-      it "slices the correct parameters" do
-        expect(client).to receive(:get).with("/api/search/latestVersion",
-          g: "group",
-          a: "name"
-        ).once
-        described_class.latest_version(
-          group: "group",
-          name: "name",
-          fizz: "foo"
-        )
-      end
-
-      it "returns the latest version" do
-        expect(described_class.latest_version).to eq("1.2-SNAPSHOT")
-      end
-
-      it "returns an nil when the server responses with a 404" do
-        allow(client).to receive(:get).and_raise(Error::HTTPError.new("status" => 404))
-
-        expect(described_class.latest_version).to be_nil
-      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("/some/artifact/path.deb")
-      end
-    end
-
-    describe ".from_hash" do
-      let(:hash) do
-        {
-          "uri"              => "http://localhost:8080/artifactory/api/storage/libs-release-local/org/acme/lib/ver/lib-ver.pom",
-          "downloadUri"      => "http://localhost:8080/artifactory/libs-release-local/org/acme/lib/ver/lib-ver.pom",
-          "repo"             => "libs-release-local",
-          "path"             => "/org/acme/lib/ver/lib-ver.pom",
-          "remoteUrl"        => "http://some-remote-repo/mvn/org/acme/lib/ver/lib-ver.pom",
-          "created"          => "2014-01-01 10:00 UTC",
-          "createdBy"        => "userY",
-          "lastModified"     => "2014-01-01 11:00 UTC",
-          "modifiedBy"       => "userX",
-          "lastUpdated"      => "2014-01-01 12:00 UTC",
-          "size"             => "1024",
-          "mimeType"         => "application/pom+xml",
-          "checksums"        => { "md5" => "MD5123", "sha1" => "SHA456" },
-          "originalChecksums" => { "md5" => "MD5123", "sha1" => "SHA456" },
-        }
-      end
-
-      it "creates a new instance" do
-        instance = described_class.from_hash(hash)
-        expect(instance).to be_a(described_class)
-        expect(instance.uri).to eq("http://localhost:8080/artifactory/api/storage/libs-release-local/org/acme/lib/ver/lib-ver.pom")
-        expect(instance.client).to be(client)
-        expect(instance.created).to eq(Time.parse("2014-01-01 10:00 UTC"))
-        expect(instance.download_uri).to eq("http://localhost:8080/artifactory/libs-release-local/org/acme/lib/ver/lib-ver.pom")
-        expect(instance.last_modified).to eq(Time.parse("2014-01-01 11:00 UTC"))
-        expect(instance.last_updated).to eq(Time.parse("2014-01-01 12:00 UTC"))
-        expect(instance.md5).to eq("MD5123")
-        expect(instance.mime_type).to eq("application/pom+xml")
-        expect(instance.sha1).to eq("SHA456")
-        expect(instance.size).to eq(1024)
-      end
-    end
-
-    describe "#copy" do
-      let(:destination) { "/to/here" }
-      let(:options)     { Hash.new }
-      before { allow(subject).to receive(:copy_or_move) }
-
-      it "delegates to #copy_or_move" do
-        expect(subject).to receive(:copy_or_move).with(:copy, destination, options)
-        subject.copy(destination, options)
-      end
-    end
-
-    describe "#delete" do
-      let(:client) { double }
-
-      it "sends DELETE to the client" do
-        subject.client = client
-        subject.download_uri = "/artifact.deb"
-
-        expect(client).to receive(:delete)
-        subject.delete
-      end
-    end
-
-    describe "#move" do
-      let(:destination) { "/to/here" }
-      let(:options)     { Hash.new }
-      before { allow(subject).to receive(:copy_or_move) }
-
-      it "delegates to #copy_or_move" do
-        expect(subject).to receive(:copy_or_move).with(:move, destination, options)
-        subject.move(destination, options)
-      end
-    end
-
-    describe "#properties" do
-      let(:properties) do
-        { "artifactory.licenses" => ["Apache-2.0"] }
-      end
-      let(:response) do
-        { "properties" => properties }
-      end
-
-      let(:client) { double(get: response) }
-      let(:relative_path) { "/api/storage/some-repo/path/artifact.deb" }
-      let(:artifact_uri) { File.join("http://33.33.33.11", relative_path) }
-
-      let(:property_set_path) { "#{relative_path}?properties=;author=J%C3%B6rg;status=public" }
-      let(:new_properties) { { author: "Jörg", "status" => "public" } }
-      let(:client) { double(put: nil ) }
-
-      before do
-        subject.client = client
-        subject.uri    = artifact_uri
-      end
-
-      it "gets the properties from the server" do
-        expect(client).to receive(:get).with(relative_path, properties: nil).once
-        expect(subject.properties).to eq(properties)
-      end
-
-      it "caches the response" do
-        subject.properties
-        expect(subject.instance_variable_get(:@properties)).to eq(properties)
-      end
-
-      it "sets the properties on the server" do
-        expect(client).to receive(:put).with(property_set_path, nil).once
-        subject.properties(new_properties)
-      end
-
-      it "updates the chache" do
-        expect(subject).to receive(:get_properties).with(true).once
-        subject.properties(new_properties)
-      end
-    end
-
-    describe "#compliance" do
-      let(:compliance) do
-        { "licenses" => [{ "name" => "LGPL v3" }] }
-      end
-      let(:client) { double(get: compliance) }
-      let(:uri) { "/artifact.deb" }
-
-      before do
-        subject.client = client
-        subject.uri = uri
-      end
-
-      it "gets the compliance from the server" do
-        expect(client).to receive(:get).with("/api/compliance/artifact.deb").once
-        expect(subject.compliance).to eq(compliance)
-      end
-
-      it "caches the response" do
-        subject.compliance
-        expect(subject.instance_variable_get(:@compliance)).to eq(compliance)
-      end
-    end
-
-    describe "#download" do
-      it "download content to directory" do
-        Dir.mktmpdir("artifact_download") do |tmpdir|
-          subject.download_uri = "/artifact.deb"
-
-          expect(client).to receive(:get) { "some content" }
-          subject.download(tmpdir)
-          expect(Dir.entries(tmpdir)).to include("artifact.deb")
-        end
-      end
-
-      it "download content to directory with filename" do
-        Dir.mktmpdir("artifact_download") do |tmpdir|
-          subject.download_uri = "/artifact.deb"
-
-          expect(client).to receive(:get) { "some content" }
-          subject.download(tmpdir, { filename: "foobar.deb" })
-          expect(Dir.entries(tmpdir)).to include("foobar.deb")
-        end
-      end
-
-      it "writes the file in chunks" do
-        Dir.mktmpdir("artifact_download") do |tmpdir|
-          subject.download_uri = "/artifact.deb"
-
-          expect(client).to receive(:get).and_yield("some content")
-
-          file = double("file")
-          expect(File).to receive(:open).with(File.join(tmpdir, "artifact.deb"), "wb").and_yield(file)
-          expect(file).to receive(:write).with("some content")
-
-          subject.download(tmpdir)
-        end
-      end
-    end
-
-    describe "#relative_path" do
-      before { described_class.send(:public, :relative_path) }
-
-      it "parses the relative path" do
-        subject.uri = "/api/storage/foo/bar/zip"
-        expect(subject.relative_path).to eq("/foo/bar/zip")
-      end
-    end
-
-    describe "#copy_or_move" do
-      let(:client) { double }
-      before do
-        described_class.send(:public, :copy_or_move)
-
-        subject.client = client
-        subject.uri = "/api/storage/foo/bar/artifact.deb"
-      end
-
-      it "sends POST to the client with parsed params" do
-        expect(client).to receive(:post).with("/api/move/foo/bar/artifact.deb?to=/to/path", {})
-        subject.copy_or_move(:move, "/to/path")
-      end
-
-      it "adds the correct parameters to the request" do
-        expect(client).to receive(:post).with("/api/move/foo/bar/artifact.deb?to=/to/path&failFast=1&dry=1", {})
-        subject.copy_or_move(:move, "/to/path", fail_fast: true, dry_run: true)
-      end
-    end
-  end
-end