brickset_api 0.1.0

data/lib/brickset/elements/user_note.rb

@@ -0,0 +1,12 @@
+module Brickset
+  module Elements
+    class UserNote
+      include HappyMapper
+
+      tag 'userNotes'
+
+      element :set_id, Integer, tag: 'setID'
+      element :user_notes, String, tag: 'userNotes'
+    end
+  end
+end

data/lib/brickset/elements/year.rb

@@ -0,0 +1,13 @@
+module Brickset
+  module Elements
+    class Year
+      include HappyMapper
+
+      tag 'years'
+
+      element :theme, String
+      element :year, String
+      element :set_count, Integer, tag: 'setCount'
+    end
+  end
+end

data/lib/brickset/version.rb

@@ -0,0 +1,3 @@
+module Brickset
+  VERSION = '0.1.0'
+end

data/spec/brickset/api/auth_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe Brickset::Client do
+  let(:api_key) { Brickset.configuration.api_key }
+
+  describe '#login' do
+    let(:username) { 'darth-vader' }
+    let(:password) { 'i-am-your-father' }
+
+    context 'with valid credentials and API key' do
+      before { stub_post('/login').with(body: "username=#{username}&password=#{password}&apiKey=#{api_key}").to_return body: fixture('login.xml') }
+
+      it 'receives an user hash' do
+        expect(subject.login(username, password)).to eq 'abc123!@#'
+      end
+    end
+
+    context 'with invalid credentials' do
+      let(:password) { 'invalid' }
+
+      before { stub_post('/login').with(body: "username=#{username}&password=#{password}&apiKey=#{api_key}").to_return body: fixture('login_invalid_credentials.xml') }
+
+      it 'receives an error response' do
+        expect(subject.login(username, password)).to eq 'ERROR: invalid username and/or password'
+      end
+    end
+
+    context 'with an invalid API key' do
+      before do
+        allow(Brickset).to receive(:configuration).and_return double(api_key: 'invalid')
+        stub_post('/login').with(body: "username=#{username}&password=#{password}&apiKey=#{api_key}").to_return body: fixture('login_invalid_key.xml')
+      end
+
+      it 'receives an INVALIDKEY response' do
+        expect(subject.login(username, password)).to eq 'INVALIDKEY'
+      end
+    end
+  end
+
+  describe '#valid_api_key?' do
+    context 'with a valid API key' do
+      before { stub_post('/checkKey').with(body: "apiKey=#{api_key}").to_return body: fixture('api_key_valid.xml') }
+
+      it 'returns true' do
+        expect(subject.valid_api_key?).to eq true
+      end
+    end
+
+    context 'with an invalid API key' do
+      before do
+        allow(Brickset).to receive(:configuration).and_return double(api_key: 'invalid')
+        stub_post('/checkKey').with(body: "apiKey=#{api_key}").to_return body: fixture('api_key_invalid.xml')
+      end
+
+      it 'returns false' do
+        expect(subject.valid_api_key?).to eq false
+      end
+    end
+  end
+
+  describe '#valid_token?' do
+    subject { described_class.new(token: token) }
+
+    context 'with a valid token' do
+      let(:token) { 'valid' }
+
+      before { stub_post('/checkUserHash').with(body: "apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('token_valid.xml') }
+
+      it 'returns true' do
+        expect(subject.valid_token?).to eq true
+      end
+    end
+
+    context 'with an invalid token' do
+      let(:token) { 'invalid' }
+
+      before { stub_post('/checkUserHash').with(body: "apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('token_invalid.xml') }
+
+      it 'returns false' do
+        expect(subject.valid_token?).to eq false
+      end
+    end
+  end
+end

data/spec/brickset/api/collection/advanced_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Brickset::Client, type: :model do
+  let(:api_key) { Brickset.configuration.api_key }
+  let(:token)   { 'valid' }
+
+  subject { described_class.new(token: token) }
+
+  describe 'validations' do
+    it { is_expected.to validate_inclusion_of(:condition).in_array(%w(acquired now)).on :collection_detail_conditions }
+  end
+
+  describe 'getCollectionDetail' do
+    context 'with valid parameters' do
+      before { stub_post('/getCollectionDetail').with(body: "setID=26907&apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('get_collection_detail.xml') }
+
+      it 'receives the collection detail' do
+        expect(subject.collection_detail(26907)).to be_a Brickset::Elements::CollectionDetail
+      end
+    end
+
+    context 'with an invalid parameter' do
+      before do
+        stub_post('/getCollectionDetail').with(body: "setID=non-existent&apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('get_collection_detail_no_result.xml')
+      end
+
+      it 'does not receive any collection detail' do
+        expect(subject.collection_detail('non-existent')).to be_nil
+      end
+    end
+  end
+
+  describe 'getCollectionDetailConditions' do
+    context 'with a valid condition' do
+      before do
+        stub_post('/getCollectionDetailConditions').with(body: "which=acquired&apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('get_collection_detail_conditions.xml')
+      end
+
+      it 'receives the collection detail conditions' do
+        expect(subject.collection_detail_conditions('acquired')).to match_array [
+          an_instance_of(Brickset::Elements::Condition),
+          an_instance_of(Brickset::Elements::Condition),
+          an_instance_of(Brickset::Elements::Condition),
+          an_instance_of(Brickset::Elements::Condition),
+          an_instance_of(Brickset::Elements::Condition),
+          an_instance_of(Brickset::Elements::Condition),
+          an_instance_of(Brickset::Elements::Condition)
+        ]
+      end
+    end
+
+    context 'with an invalid condition' do
+      it 'raises a ValidationError' do
+        expect { subject.collection_detail_conditions('invalid-condition') }.to raise_error Brickset::ValidationError, 'Condition is not included in the list'
+      end
+    end
+  end
+
+end

data/spec/brickset/api/collection/minifig_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+RSpec.describe Brickset::Client, type: :model do
+  let(:api_key) { Brickset.configuration.api_key }
+  let(:token)   { 'valid' }
+
+  subject { described_class.new(token: token) }
+
+  context 'validations' do
+    it { is_expected.to validate_presence_of(:minifig_number).on :update_minifig_collection }
+    it { is_expected.to validate_presence_of(:number_owned).on :update_minifig_collection }
+    it { is_expected.to validate_presence_of(:wanted).on :update_minifig_collection }
+    it { is_expected.to validate_inclusion_of(:number_owned).in_range(0..999).on :update_minifig_collection }
+    it { is_expected.to validate_inclusion_of(:wanted).in_array([0, 1]).on :update_minifig_collection }
+  end
+
+  describe '#minifig_collection' do
+    context 'with valid parameters' do
+      context 'when using the query parameter' do
+        before { stub_post('/getMinifigCollection').with(body: "query=Star%20Wars&owned=&wanted=&apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('get_minifig_collection.xml') }
+
+        it 'returns the minifig collections that match the search query' do
+          expect(subject.minifig_collection(query: 'Star Wars')).to match_array [
+            an_instance_of(Brickset::Elements::MinifigCollection),
+            an_instance_of(Brickset::Elements::MinifigCollection),
+            an_instance_of(Brickset::Elements::MinifigCollection),
+            an_instance_of(Brickset::Elements::MinifigCollection)
+          ]
+        end
+      end
+
+      context 'when using the owned parameter' do
+        before { stub_post('/getMinifigCollection').with(body: "query=&owned=1&wanted=&apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('get_minifig_collection_owned.xml') }
+
+        it 'returns the owned minifig collections' do
+          expect(subject.minifig_collection(owned: '1')).to match_array [
+            an_instance_of(Brickset::Elements::MinifigCollection),
+            an_instance_of(Brickset::Elements::MinifigCollection)
+          ]
+        end
+      end
+      context 'when using the wanted parameter' do
+        before { stub_post('/getMinifigCollection').with(body: "query=&owned=&wanted=1&apiKey=#{api_key}&userHash=#{token}").to_return body: fixture('get_minifig_collection_wanted.xml') }
+
+        it 'returns the wanted minifig collections' do
+          expect(subject.minifig_collection(wanted: '1')).to match_array [
+            an_instance_of(Brickset::Elements::MinifigCollection)
+          ]
+        end
+      end
+    end
+  end
+
+  describe '#update_minifig_collection' do
+    let(:minifig_number) { '47205pb026' }
+    let(:number_owned) { 2 }
+    let(:wanted) { 1 }
+
+    let(:update_minifig_collection) { subject.update_minifig_collection(minifig_number: minifig_number, number_owned: number_owned, wanted: wanted) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setMinifigCollection').with(body: "minifigNumber=#{minifig_number}&qtyOwned=#{number_owned}&wanted=#{wanted}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_minifig_collection.xml') }
+
+        it 'updates the specified minifig collection' do
+          expect(update_minifig_collection).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_minifig_collection_invalid.xml') }
+
+        it 'does not update the specified minifig collection' do
+          expect(update_minifig_collection).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_minifig_collection
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:minifig_number) { nil }
+      let(:wanted) { true }
+
+      it 'raises a ValidationError' do
+        expect { update_minifig_collection }.to raise_error Brickset::ValidationError, "Minifig number can't be blank and Wanted is not included in the list"
+      end
+    end
+  end
+end

data/spec/brickset/api/collection/set_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+RSpec.describe Brickset::Client, type: :model do
+  let(:api_key) { Brickset.configuration.api_key }
+  let(:token)   { 'valid' }
+
+  subject { described_class.new(token: token) }
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:set_id).on :update_collection }
+    it { is_expected.to validate_presence_of(:number_owned).on :update_collection }
+    it { is_expected.to validate_presence_of(:wanted).on :update_collection }
+    it { is_expected.to validate_inclusion_of(:number_owned).in_range(0..999).on :update_collection }
+    it { is_expected.to validate_inclusion_of(:wanted).in_array([0, 1]).on :update_collection }
+
+    it { is_expected.to validate_presence_of(:set_id).on :update_collection_owned }
+    it { is_expected.to validate_presence_of(:owned).on :update_collection_owned }
+    it { is_expected.to validate_inclusion_of(:owned).in_array([0, 1]).on :update_collection_owned }
+
+    it { is_expected.to validate_presence_of(:set_id).on :update_collection_wanted }
+    it { is_expected.to validate_presence_of(:wanted).on :update_collection_wanted }
+    it { is_expected.to validate_inclusion_of(:wanted).in_array([0, 1]).on :update_collection_wanted }
+
+    it { is_expected.to validate_presence_of(:set_id).on :update_collection_number_owned }
+    it { is_expected.to validate_presence_of(:number_owned).on :update_collection_number_owned }
+    it { is_expected.to validate_inclusion_of(:number_owned).in_range(0..999).on :update_collection_number_owned }
+
+    it { is_expected.to validate_presence_of(:set_id).on :update_collection_user_notes }
+    it { is_expected.to validate_presence_of(:notes).on :update_collection_user_notes }
+    it { is_expected.to validate_length_of(:notes).is_at_most(200).on :update_collection_user_notes }
+
+    it { is_expected.to validate_presence_of(:set_id).on :update_user_rating }
+    it { is_expected.to validate_presence_of(:rating).on :update_user_rating }
+    it { is_expected.to validate_inclusion_of(:rating).in_range(0..5).on :update_user_rating }
+  end
+
+  describe '#collection_totals' do
+    let(:body) { fixture('get_collection_totals.xml') }
+
+    before { stub_post('/getCollectionTotals').with(body: "apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+    context 'with valid parameters' do
+      it 'returns the collection totals' do
+        aggregate_failures do
+          expect(subject.collection_totals).to be_a Brickset::Elements::CollectionTotal
+          expect(subject.collection_totals.total_sets_owned).to eq 126
+          expect(subject.collection_totals.total_sets_wanted).to eq 85
+          expect(subject.collection_totals.total_minifigs_owned).to eq 156
+          expect(subject.collection_totals.total_minifigs_wanted).to eq 40
+          expect(subject.collection_totals.total_distinct_sets_owned).to eq 121
+        end
+      end
+    end
+
+    context 'with invalid parameters' do
+      let(:token) { 'invalid' }
+      let(:body) { fixture('get_collection_totals_no_result.xml') }
+
+      it 'returns a collection total with default values' do
+        aggregate_failures do
+          expect(subject.collection_totals).to be_a Brickset::Elements::CollectionTotal
+          expect(subject.collection_totals.total_sets_owned).to eq 0
+          expect(subject.collection_totals.total_sets_wanted).to eq 0
+          expect(subject.collection_totals.total_minifigs_owned).to eq 0
+          expect(subject.collection_totals.total_minifigs_wanted).to eq 0
+          expect(subject.collection_totals.total_distinct_sets_owned).to eq 0
+        end
+      end
+    end
+  end
+
+  describe '#update_collection' do
+    let(:set_id) { 26725 }
+    let(:number_owned) { 2 }
+    let(:wanted) { 1 }
+
+    let(:update_collection) { subject.update_collection(set_id: set_id, number_owned: number_owned, wanted: wanted) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setCollection').with(body: "setID=#{set_id}&qtyOwned=#{number_owned}&wanted=#{wanted}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_collection.xml') }
+
+        it 'updates the specified collection' do
+          expect(update_collection).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_collection_invalid.xml') }
+
+        it 'does not update the specified collection' do
+          expect(update_collection).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_collection
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:set_id) { nil }
+      let(:wanted) { true }
+
+      it 'raises a ValidationError' do
+        expect { update_collection }.to raise_error Brickset::ValidationError, "Set can't be blank and Wanted is not included in the list"
+      end
+    end
+  end
+
+  describe '#update_collection_owned' do
+    let(:set_id) { 26725 }
+    let(:owned) { 1 }
+
+    let(:update_collection_owned) { subject.update_collection_owned(set_id: set_id, owned: owned) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setCollection_owns').with(body: "setID=#{set_id}&owned=#{owned}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_collection_owns.xml') }
+
+        it 'updates the specified collection owned' do
+          expect(update_collection_owned).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_collection_owns_invalid.xml') }
+
+        it 'does not update the specified collection owned' do
+          expect(update_collection_owned).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_collection_owned
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:set_id) { nil }
+      let(:owned) { true }
+
+      it 'raises a ValidationError' do
+        expect { update_collection_owned }.to raise_error Brickset::ValidationError, "Set can't be blank and Owned is not included in the list"
+      end
+    end
+  end
+
+  describe '#update_collection_wanted' do
+    let(:set_id) { 26725 }
+    let(:wanted) { 1 }
+
+    let(:update_collection_wanted) { subject.update_collection_wanted(set_id: set_id, wanted: wanted) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setCollection_wants').with(body: "setID=#{set_id}&wanted=#{wanted}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_collection_wants.xml') }
+
+        it 'updates the specified collection wanted' do
+          expect(update_collection_wanted).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_collection_wants_invalid.xml') }
+
+        it 'does not update the specified collection wanted' do
+          expect(update_collection_wanted).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_collection_wanted
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:set_id) { nil }
+      let(:wanted) { true }
+
+      it 'raises a ValidationError' do
+        expect { update_collection_wanted }.to raise_error Brickset::ValidationError, "Set can't be blank and Wanted is not included in the list"
+      end
+    end
+  end
+
+  describe '#update_collection_number_owned' do
+    let(:set_id) { 26725 }
+    let(:number_owned) { 1 }
+
+    let(:update_collection_number_owned) { subject.update_collection_number_owned(set_id: set_id, number_owned: number_owned) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setCollection_qtyOwned').with(body: "setID=#{set_id}&qtyOwned=#{number_owned}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_collection_qty_owned.xml') }
+
+        it 'updates the specified collection number owned' do
+          expect(update_collection_number_owned).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_collection_qty_owned_invalid.xml') }
+
+        it 'does not update the specified collection number owned' do
+          expect(update_collection_number_owned).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_collection_number_owned
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:set_id) { nil }
+      let(:number_owned) { true }
+
+      it 'raises a ValidationError' do
+        expect { update_collection_number_owned }.to raise_error Brickset::ValidationError, "Set can't be blank and Number owned is not included in the list"
+      end
+    end
+  end
+
+  describe '#update_collection_user_notes' do
+    let(:set_id) { 26725 }
+    let(:notes) { "She's the fastest hunk of junk in the galaxy!" }
+
+    let(:update_collection_user_notes) { subject.update_collection_user_notes(set_id: set_id, notes: notes) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setCollection_userNotes').with(body: "setID=#{set_id}&notes=#{ERB::Util.url_encode(notes)}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_collection_user_notes.xml') }
+
+        it 'updates the specified collection user notes' do
+          expect(update_collection_user_notes).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_collection_user_notes_invalid.xml') }
+
+        it 'does not update the specified collection user notes' do
+          expect(update_collection_user_notes).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_collection_user_notes
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:set_id) { nil }
+      let(:notes) { 'Star Wars. ' * 20 }
+
+      it 'raises a ValidationError' do
+        expect { update_collection_user_notes }.to raise_error Brickset::ValidationError, "Set can't be blank and Notes is too long (maximum is 200 characters)"
+      end
+    end
+  end
+
+  describe '#update_user_rating' do
+    let(:set_id) { 26725 }
+    let(:rating) { 4 }
+
+    let(:update_user_rating) { subject.update_user_rating(set_id: set_id, rating: rating) }
+
+    context 'when all required parameters are specified' do
+      before { stub_post('/setUserRating').with(body: "setID=#{set_id}&rating=#{rating}&apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+      context 'when all parameters are valid' do
+        let(:body) { fixture('set_user_rating.xml') }
+
+        it 'updates the specified user rating' do
+          expect(update_user_rating).to eq true
+        end
+      end
+
+      context 'when a parameter is invalid' do
+        let(:body) { fixture('set_user_rating_invalid.xml') }
+
+        it 'does not update the specified user rating' do
+          expect(update_user_rating).to eq false
+        end
+
+        it 'sets the error on the client' do
+          update_user_rating
+          expect(subject.errors[:base]).to match_array [ 'ERROR: invalid userHash' ]
+        end
+      end
+    end
+
+    context 'when not all parameters are valid' do
+      let(:set_id) { nil }
+      let(:rating) { 6 }
+
+      it 'raises a ValidationError' do
+        expect { update_user_rating }.to raise_error Brickset::ValidationError, "Set can't be blank and Rating is not included in the list"
+      end
+    end
+  end
+
+  describe '#user_notes' do
+    let(:body) { fixture('get_user_notes.xml') }
+
+    before { stub_post('/getUserNotes').with(body: "apiKey=#{api_key}&userHash=#{token}").to_return body: body }
+
+    context 'with valid parameters' do
+      it 'returns the users notes' do
+        aggregate_failures do
+          expect(subject.user_notes).to match_array [
+            an_instance_of(Brickset::Elements::UserNote),
+            an_instance_of(Brickset::Elements::UserNote)
+          ]
+          expect(subject.user_notes.count).to eq 2
+          expect(subject.user_notes.first.set_id).to eq 5860
+          expect(subject.user_notes.first.user_notes).to eq 'A long time ago in a galaxy far, far away...'
+          expect(subject.user_notes.last.set_id).to eq 26725
+          expect(subject.user_notes.last.user_notes).to eq 'The ship that made the Kessel Run in less than 12 parsecs.'
+        end
+      end
+    end
+
+    context 'with invalid parameters' do
+      let(:token) { 'invalid' }
+      let(:body) { fixture('get_user_notes_no_result.xml') }
+
+      it 'does not receive any user notes' do
+        expect(subject.user_notes).to match_array []
+      end
+    end
+  end
+
+end