shutterstock-v2 0.0.1

data/spec/client/images_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Images do
+  before do
+    client
+  end
+
+  let(:id) { 32_329_852 }
+  subject(:images) { Image.find(id).similar  }
+
+  it 'returns similar images' do
+    expect(images).to_not be_nil
+    expect(images).to be_kind_of Array
+    expect(images).to be_kind_of Images
+    expect(images[0]).to be_kind_of Image
+    expect(images.raw_data).to be_kind_of Hash
+    expect(images.page).to be 1
+    expect(images.total_count).to eq 200
+    expect(images.search_id).to_not be_nil
+  end
+
+  describe "fill" do
+    it 'fills details of all images in list: all images now have keywords' do
+      similar = images
+      expect(similar.select{|img| img.keywords.class == Array}.count).to eq 0
+      similar.fill
+      expect(similar.select{|img| img.keywords.class != Array}.count).to eq 0
+    end
+  end
+
+end

data/spec/client/license_spec.rb

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+describe License do
+
+  before do
+    client
+  end
+
+  context 'params' do
+
+    it 'stores params correctly' do
+      subject = License.new("image_id" =>"42194962",
+                            "download" =>{"url" =>"https://download.shutterstock.com/shutterstock_42194962.jpg"},
+                            "allotment_charge" => 1)
+
+
+      expect(License).to respond_to(:license)
+
+      expect(subject).to_not be_nil
+      expect(subject.image_id).to eq 42194962
+      expect(subject.download).to eq "https://download.shutterstock.com/shutterstock_42194962.jpg"
+      expect(subject.allotment_charge).to eq 1
+    end
+
+  end
+
+  context 'license' do
+
+
+    let(:subscription_id) { "s30187600" }
+    let(:bad_image_id) { 509_205_923_049 }
+
+    context 'single' do
+
+      let(:bad_subscription_id) { "s987654" }
+      let(:image_id) { 138_869_051 }
+      let(:image2) { Image.new("id" => "145104193") }
+      let(:image3) { { "image_id" => "157910507" } }
+      let(:vector_image_id) { 109675343 }
+
+
+      it 'returns error when neither image or subscription id passed' do
+        expect { License.license(subscription_id: subscription_id) }.to raise_error(ArgumentError)
+        expect { License.license(image_id: image_id) }.to raise_error(ArgumentError)
+      end
+
+      it 'returns error when incorrect image used' do
+        license = License.license(subscription_id: subscription_id, image_id: bad_image_id)
+        expect( license.error ).to eq "Media unavailable"
+      end
+
+      it 'returns error when incorrect subscription used' do
+        license = License.license(subscription_id: bad_subscription_id, image_id: image_id)
+        expect( license.error ).to eq "Subscription is unusable"
+      end
+
+      it 'licenses single image' do
+        license = License.license(subscription_id: subscription_id, image_id: image_id, format: "jpg", size: "huge")
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image_id
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'licenses single image from Image.new' do
+        license = License.license(subscription_id: subscription_id, image_id: image2, format: "jpg", size: "huge")
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image2.id
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'licenses single image from hash' do
+        license = License.license(subscription_id: subscription_id, image_id: image3, format: "jpg", size: "huge")
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image3["image_id"].to_i
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'error when format is eps but size is not vector' do
+        expect { License.license(subscription_id: subscription_id, image_id: vector_image_id, format: "eps") }.to raise_error(ArgumentError)
+      end
+
+      it 'licenses vector image' do
+        license = License.license(subscription_id: subscription_id, image_id: vector_image_id, format: "eps", size: "vector")
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq vector_image_id
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'licenses single image with smaller size' do
+        license = License.license(subscription_id: subscription_id, image_id: image3, format: "jpg", size: "small")
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image3["image_id"].to_i
+        expect( license.error ).to be nil
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'license fails when subscription doesn\'t allow' do
+        expect { License.license(subscription_id: subscription_id, image_id: image3, format: "tiff", size: "small") }.to raise_error(FailedResponse)
+      end
+
+      it 'licencing same image twice does not give error' do
+        license = License.license(subscription_id: subscription_id, image_id: image3, format: "jpg", size: "huge")
+        expect( license ).to be_a License
+        license = License.license(subscription_id: subscription_id, image_id: image3, format: "jpg", size: "huge")
+        expect( license.allotment_charge ).to eq 0
+      end
+
+
+    end
+
+    context 'multiple' do
+
+      let(:image_ids) { [312464573, 313292420, 314250722] }
+      let(:image_ids_as_images) { [431616757, 461729398, 94306576].map{|id| Image.new("id" => id)} }
+
+      it 'returns error when neither image or subscription id passed' do
+        expect { License.license_multiple(subscription_id: subscription_id) }.to raise_error(ArgumentError)
+        expect { License.license_multiple(image_id: image_ids) }.to raise_error(ArgumentError)
+      end
+
+      it 'licenses multiple images' do
+        licenses = License.license_multiple(subscription_id: subscription_id, image_id: image_ids, format: "jpg", size: "huge")
+        expect( licenses ).to be_a Licenses
+        expect( licenses.count ).to eq 3
+        expect( licenses.errors ).to be nil
+
+        first_license = licenses.first
+        expect( first_license ).to be_a License
+        expect( first_license.image_id ).to eq image_ids.first
+        expect( first_license.error ).to be nil
+        expect( first_license.allotment_charge ).to be 1
+        expect( first_license.download ).to be_a String
+        expect( first_license.download ).to match /download\.shutterstock/
+      end
+
+      it 'licenses multiple images from Image.new' do
+        licenses = License.license_multiple(subscription_id: subscription_id, image_id: image_ids_as_images, format: "jpg", size: "small")
+        expect( licenses ).to be_a Licenses
+        expect( licenses.count ).to eq 3
+        expect( licenses.errors ).to be nil
+
+        first_license = licenses.first
+        expect( first_license ).to be_a License
+        expect( first_license.image_id ).to eq image_ids_as_images.first.id
+        expect( first_license.error ).to be nil
+        expect( first_license.allotment_charge ).to be 1
+        expect( first_license.download ).to be_a String
+        expect( first_license.download ).to match /download\.shutterstock/
+      end
+
+      it 'returns error in Licenses when incorrect image used' do
+        licenses = License.license_multiple(subscription_id: subscription_id, image_id: [bad_image_id])
+        expect( licenses.errors ).to be_a Array
+        expect( licenses.errors.first["message"] ).to eq "Failed to license 1 image"
+        expect( licenses.first.error ).to eq "Media unavailable"
+      end
+    end
+
+    context 'editorial_acknowledgement' do
+
+      let(:image_id_needing_ed_ack) { 204_501_694 }
+
+
+      it 'returns error if requesting an image that needs editorial acknowledgement' do
+        license = License.license(subscription_id: subscription_id, image_id: image_id_needing_ed_ack)
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image_id_needing_ed_ack
+        expect( license.error ).to eq "Editorial status must be acknowledged"
+      end
+
+      it 'returns licenced image if ed ack is sent' do
+        license = License.license(subscription_id: subscription_id, image_id: image_id_needing_ed_ack, editorial_acknowledgement: true)
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image_id_needing_ed_ack
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+
+    end
+    context 'license from image object' do
+
+      let(:image) { Image.new("id" => "42194962") }
+
+      it 'using found subscription' do
+        license = image.license
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image.id
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'vector image' do
+        image = Image.new("id" => "110641004")
+        license = image.license(format: "eps", size: "vector")
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq image.id
+        expect( license.error ).to be nil
+        expect( license.allotment_charge ).to be 1
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+      it 'sends editorial_acknowledgement when image needs it' do
+        license = Image.new("id" => "204501694").fill.license
+        expect( license ).to be_a License
+        expect( license.image_id ).to eq 204501694
+        expect( license.error ).to be nil
+        expect( license.download ).to be_a String
+        expect( license.download ).to match /download\.shutterstock/
+      end
+
+    end
+
+  end
+
+end

data/spec/client/model_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Model do
+  # before do
+  #   client
+  # end
+
+  context 'initialize' do
+    it 'initializes with ID from params' do
+      expect(Model.new("id" => 1234).id).to be 1234
+    end
+  end
+
+end

data/spec/client/models_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Models do
+  before do
+    client
+  end
+
+  subject(:models) { Image.find(356308322).models  }
+
+  it 'returns all models for an image' do
+    expect(models).to_not be_nil
+    expect(models).to be_kind_of Array
+    expect(models).to be_kind_of Models
+    expect(models[0]).to be_kind_of Model
+    expect(models.raw_data).to be_kind_of Array
+  end
+
+  it 'parses params correctly' do
+    expect(models[0].id).to eq 17856134
+    expect(models[1].id).to eq 15233887
+  end
+
+end

data/spec/client/request_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Request do
+
+  describe ".new" do
+    it 'vars set in block are retained' do
+      result = Shutterstock::Request.new do |r|
+        r.method ('method')
+        r.path ('path')
+        r.success_status (123)
+        r.send_authorization (false)
+        r.content_type ('type')
+        r.body ('body')
+        r.params ('params')
+      end
+
+      expect(result.method).to eq 'method'
+      expect(result.path).to eq 'path'
+      expect(result.success_status).to eq 123
+      expect(result.send_authorization).to eq false
+      expect(result.content_type).to eq 'type'
+      expect(result.body).to eq 'body'
+      expect(result.params).to eq 'params'
+
+    end
+
+    it 'can use DSL' do
+      result = Shutterstock::Request.new do
+        method ('method')
+        path ('path')
+        success_status (123)
+        send_authorization (false)
+        content_type ('type')
+        body ('body')
+        params ('params')
+      end
+
+      expect(result.method).to eq 'method'
+      expect(result.path).to eq 'path'
+      expect(result.success_status).to eq 123
+      expect(result.send_authorization).to eq false
+      expect(result.content_type).to eq 'type'
+      expect(result.body).to eq 'body'
+      expect(result.params).to eq 'params'
+
+    end
+
+    it 'can use equals to set' do
+
+      result = Shutterstock::Request.new do |r|
+        r.method = 'method'
+        r.path = 'path'
+        r.success_status = 123
+        r.send_authorization = false
+        r.content_type = 'type'
+        r.body = 'body'
+        r.params = 'params'
+      end
+
+      expect(result.method).to eq 'method'
+      expect(result.path).to eq 'path'
+      expect(result.success_status).to eq 123
+      expect(result.send_authorization).to eq false
+      expect(result.content_type).to eq 'type'
+      expect(result.body).to eq 'body'
+      expect(result.params).to eq 'params'
+
+    end
+
+    it 'sets sensible defaults' do
+      result = Shutterstock::Request.new
+
+      expect(result.success_status).to eq 200
+      expect(result.send_authorization).to eq true
+      expect(result.content_type).to eq 'application/json'
+
+    end
+  end
+end

data/spec/client/subscription_allotment_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe SubscriptionAllotment do
+  # before do
+  #   client
+  # end
+
+  context 'initialize' do
+    it 'initializes with data from params' do
+      subject = SubscriptionAllotment.new("downloads_left" => 10, "downloads_limit" => 30, "start_time" => "2016-12-28T09:36:49-05:00", "end_time" => "2017-12-28T09:36:49-10:00")
+      expect(subject.downloads_left).to eq 10
+      expect(subject.downloads_limit).to eq 30
+      expect(subject.start_time).to eq DateTime.parse("2016-12-28T09:36:49-05:00")
+      expect(subject.end_time).to eq DateTime.parse("2017-12-28T09:36:49-10:00")
+    end
+
+    it '.has_downloads_left?' do
+      subject = SubscriptionAllotment.new("downloads_left" => 10, "downloads_limit" => 30)
+      expect(subject.has_downloads_left?).to be true
+      subject = SubscriptionAllotment.new("downloads_left" => 0, "downloads_limit" => 30)
+      expect(subject.has_downloads_left?).to be false
+    end
+  end
+
+end

data/spec/client/subscription_license_format_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe SubscriptionLicenseFormat do
+  before do
+    client
+  end
+
+  context 'new' do
+
+    subject { User.subscriptions.first.formats.first }
+
+    it 'returns a subscription license format for current user' do
+      expect(subject).to_not be_nil
+      expect(subject).to be_a SubscriptionLicenseFormat
+    end
+
+    it 'parses info correctly' do
+      # Test variables from this specific API call.
+      # Might break if vcr recording is deleted. If so, use new values
+      expect(subject.description).to eq "Huge"
+      expect(subject.min_resolution).to eq 4000000
+      expect(subject.media_type).to eq "image"
+      expect(subject.format).to eq "jpg"
+      expect(subject.size).to eq "huge"
+    end
+
+  end
+
+end

data/spec/client/subscription_price_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe SubscriptionPrice do
+  # before do
+  #   client
+  # end
+
+  context 'initialize' do
+    it 'initializes with data from params' do
+      subject = SubscriptionPrice.new("local_amount" => 10.40, "local_currency" => "USD")
+      expect(subject.local_amount).to eq 10.40
+      expect(subject.local_currency).to eq "USD"
+    end
+
+  end
+
+end