john_stamos 0.0.1

data/spec/lib/john_stamos/client_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe JohnStamos::Client, :vcr do
+  subject(:client) { JohnStamos::Client.new }
+  let(:pinterest_url) { 'https://pinterest.com' }
+
+  describe '#search_pins' do
+    it 'responds to #search_pins' do
+      expect(client).to respond_to(:search_pins)
+    end
+
+    it 'returns the correct number of pins' do
+      expect(client.search_pins('uncle jesse')).to have_exactly(50).pins
+    end
+  end
+
+  describe '#pin' do
+    it 'responds to #pin' do
+      expect(client).to respond_to(:pin)
+    end
+
+    it 'returns a Pin' do
+      expect(client.pin(412149803369441273)).to be_a(JohnStamos::Pin)
+    end
+  end
+
+  describe '#pinner' do
+    it 'responds to #pinner' do
+      expect(client).to respond_to(:pinner)
+    end
+
+    it 'returns a Pinner' do
+      expect(client.pinner('johnstamosgem')).to be_a(JohnStamos::Pinner)
+    end
+  end
+
+  describe '#proxy' do
+    it 'responds to #proxy' do
+      expect(client).to respond_to(:proxy)
+    end
+
+    it 'initializes w/ a nil proxy by default' do
+      expect(client.proxy).to be_nil
+    end
+
+    it 'initializes the proxy attribute when constructed' do
+      client = JohnStamos::Client.new(proxy: 'test')
+      expect(client.proxy).to eq('test')
+    end
+  end
+
+  describe '#json_content' do
+    it 'responds to #json_content' do
+      expect(client).to respond_to(:json_content)
+    end
+
+    it 'returns a Hash' do
+      RestClient.stub(:get).and_return('{"json":"json"}')
+
+      expect(client.json_content('url', 'params')).to be_a(Hash)
+    end
+  end
+
+  describe '#mechanize_agent' do
+    let(:agent) { client.send(:mechanize_agent) }
+
+    context 'when using a proxy' do
+      before(:each) do
+        client.proxy = 'http://proxy.com:4747'
+      end
+
+      it 'sets the correct hostname' do
+        expect(agent.proxy_addr).to eq('proxy.com')
+      end
+
+      it 'sets the correct port' do
+        expect(agent.proxy_port).to eq(4747)
+      end
+    end
+
+    context 'when not using a proxy' do
+      before(:each) do
+        client.proxy = nil
+      end
+
+      it 'does not set a hostname' do
+        expect(agent.proxy_addr).to be_nil
+      end
+
+      it 'does not set a port' do
+        expect(agent.proxy_port).to be_nil
+      end
+    end
+  end
+
+  describe '#page_content' do
+    it 'responds to #page_content' do
+      expect(client).to respond_to(:page_content)
+    end
+
+    it 'returns a Mechanize::Page' do
+      expect(client.page_content(pinterest_url)).to be_a(Mechanize::Page)
+    end
+  end
+
+  describe '#json_content' do
+    let(:fake_json) { '{"json":"json"}' }
+
+    it 'responds to #json_content' do
+      expect(client).to respond_to(:json_content)
+    end
+
+    context 'when not using a proxy' do
+      before(:each) do
+        allow(RestClient).to receive(:get).and_return(fake_json)
+      end
+
+      let(:json_content) { client.json_content('url', 'params') }
+
+      it 'returns a Hash representation of the JSON' do
+        expect(json_content).to be_a(Hash)
+      end
+
+      it 'does not set RestClient proxy properties' do
+        json_content
+        expect(RestClient.proxy).to be_nil
+      end
+    end
+
+    context 'when using a proxy' do
+      let(:proxy) { 'http://proxy.com:31337' }
+      let(:proxy_client) { JohnStamos::Client.new({ proxy: proxy }) }
+
+      before(:each) do
+        allow(proxy_client).to receive(:proxy).and_return(proxy)
+        allow(RestClient).to receive(:get).and_return(fake_json)
+      end
+
+      it 'sets RestClient proxy properties' do
+        proxy_client.json_content('url', 'params')
+        expect(RestClient.proxy).to eq(proxy_client.proxy)
+      end
+    end
+
+
+  end
+end

data/spec/lib/john_stamos/pin_search_spec.rb

@@ -0,0 +1,298 @@
+require 'spec_helper'
+require 'base64'
+
+describe JohnStamos::PinSearch, :vcr do
+  subject(:scraper) { JohnStamos::PinSearch.new(client) }
+
+  let(:client) { JohnStamos::Client.new }
+  let(:search_text) { "coffee roasting" }
+
+  it 'responds to #search_text' do
+    expect(scraper).to respond_to(:search_text)
+  end
+
+  it 'responds to #next_bookmark' do
+    expect(scraper).to respond_to(:next_bookmark)
+  end
+
+  it 'responds to #pin_ids' do
+    expect(scraper).to respond_to(:pin_ids)
+  end
+
+  it 'responds to #limit' do
+    expect(scraper).to respond_to(:limit)
+  end
+
+  it 'responds to #pins' do
+    expect(scraper).to respond_to(:pins)
+  end
+
+  it 'responds to #execute!' do
+    expect(scraper).to respond_to(:execute!)
+  end
+
+  it 'responds to #first_retrieval_url' do
+    expect(scraper).to respond_to(:first_retrieval_url)
+  end
+
+  it 'responds to #subsequent_retrieval_url' do
+    expect(scraper).to respond_to(:subsequent_retrieval_url)
+  end
+
+  it 'responds to #first_retrieval!' do
+    expect(scraper).to respond_to(:first_retrieval!)
+  end
+
+  it 'responds to #subsequent_retrieval!' do
+    expect(scraper).to respond_to(:subsequent_retrieval!)
+  end
+
+  it 'responds to #more_results?' do
+    expect(scraper).to respond_to(:more_results?)
+  end
+
+  it 'responds to #limit_reached?' do
+    expect(scraper).to respond_to(:limit_reached?)
+  end
+
+
+  describe 'when initialized' do
+    it 'has no search query' do
+      expect(scraper.search_text).to be_nil
+    end
+
+    it 'has no pin ids' do
+      expect(scraper.pin_ids).to be_empty
+    end
+
+    it 'has no pins' do
+      expect(scraper.pins).to be_empty
+    end
+
+    it 'has a nil next bookmark' do
+      expect(scraper.next_bookmark).to be_nil
+    end
+
+    it 'has a limit of 50 by default' do
+      expect(scraper.limit).to eq(50)
+    end
+  end
+
+  describe '#first_retrieval_url' do
+    context 'search query not set' do
+      it 'raises an error' do
+        expect {
+          scraper.first_retrieval_url
+        }.to raise_error(JohnStamos::MissingSearchText)
+      end
+    end
+
+    it 'returns the correct URL with the search text URL encoded' do
+      scraper.search_text = search_text
+      expect(scraper.first_retrieval_url).to eq('http://pinterest.com/search/pins/?q=coffee%20roasting')
+    end
+  end
+
+  describe '#first_retrieval!' do
+
+    context 'with results found' do
+      before(:each){ scraper.search_text = search_text }
+
+      it 'sets next_bookmark' do
+        expect { scraper.first_retrieval! }.to change{ scraper.next_bookmark }.from(nil)
+      end
+
+      it 'sets next_bookmark with a hash for the next 50 results' do
+        scraper.first_retrieval!
+        decrypted_hash = Base64.strict_decode64(scraper.next_bookmark)
+        next_page_results_start_position = decrypted_hash.split('|')[0]
+        next_page_results_start_position.should eq("oo50")
+      end
+
+      it 'should set pin_ids' do
+        expect { scraper.first_retrieval! }.to change{ scraper.pin_ids.length }.from(0).to(50)
+      end
+    end
+
+    context 'without any results found' do
+      before(:each) do
+        scraper.search_text = "ThisWillNeverBeFoundLOLAmIRiteYeahYoureRite"
+      end
+
+      it 'has a nil next_bookmark' do
+        scraper.first_retrieval!
+        expect(scraper.next_bookmark).to eq('-end-')
+      end
+
+      it 'leaves the pin_ids array empty' do
+        scraper.first_retrieval!
+        expect(scraper.pin_ids).to be_empty
+      end
+    end
+  end
+
+  describe '#subsequent_retrieval_url' do
+    it 'returns the correct "resource" url' do
+      expect(scraper.subsequent_retrieval_url).to eq('http://pinterest.com/resource/SearchResource/get/')
+    end
+  end
+
+  describe '#subsequent_retrieval' do
+    it 'raises an error if there next_bookmark is not set' do
+      expect {
+        scraper.search_text = "bogus search text"
+        scraper.subsequent_retrieval!
+      }.to raise_error(JohnStamos::MissingNextBookmark)
+    end
+
+    it 'raises an error if search_text is not set' do
+      expect {
+        scraper.next_bookmark = "bogus next bookmark"
+        scraper.subsequent_retrieval!
+      }.to raise_error(JohnStamos::MissingSearchText)
+    end
+
+    context 'with results found' do
+      before(:each) do
+        scraper.search_text = 'coffee'
+        scraper.limit = 100
+        scraper.first_retrieval!
+      end
+
+      it 'sets the next_bookmark' do
+        expect { scraper.subsequent_retrieval! }.to change{ scraper.next_bookmark }
+      end
+
+      it 'sets next_bookmark with a hash for the next 50 results' do
+        scraper.subsequent_retrieval!
+        decrypted_hash = Base64.strict_decode64(scraper.next_bookmark)
+        next_page_results_start_position = decrypted_hash.split('|')[0]
+        expect(next_page_results_start_position).to eq("oo100")
+      end
+
+      it 'should append the new pin_ids' do
+        # The expected count can change based on Pinterest. Sometimes they give 99, sometimes 100.
+        # When you update the VCR cassettes it may cause this test to fail... please update it.
+        scraper.subsequent_retrieval!
+        expect(scraper.pin_ids.length).to eq(100)
+      end
+    end
+  end
+
+  describe '#more_results?' do
+    context 'when there are more results' do
+      before(:each) { scraper.next_bookmark = "some bogus bookmark" }
+
+      it 'returns true' do
+        expect(scraper.more_results?).to be_true
+      end
+    end
+
+    context 'when there are no more results' do
+      before(:each) { scraper.next_bookmark = "-end-" }
+
+      it 'returns false' do
+        expect(scraper.more_results?).to be_false
+      end
+    end
+
+    context 'when next_bookmark is nil' do
+      it 'raises a MissingNextBookmark error' do
+        expect {
+        scraper.more_results?
+        }.to raise_error(JohnStamos::MissingNextBookmark)
+      end
+    end
+  end
+
+  describe '#limit_reached?' do
+    context 'when the default limit of 50 has not been reached' do
+      before(:each) { scraper.pin_ids = Array.new(49) }
+
+      it 'returns false' do
+        expect(scraper.limit_reached?).to be_false
+      end
+    end
+
+    context 'when default limit of 50 has been reached' do
+      before(:each) { scraper.pin_ids = Array.new(50) }
+
+      it 'returns true' do
+        expect(scraper.limit_reached?).to be_true
+      end
+    end
+  end
+
+  describe '#execute!' do
+
+    context 'search query not set' do
+      it 'raises an error' do
+        expect {
+          scraper.execute!
+        }.to raise_error(JohnStamos::MissingSearchText)
+      end
+    end
+
+    context 'when using a search term that yields thousands of pins' do
+      let(:big_search_term) { "funny" }
+
+      context 'with no limit specified' do
+        subject(:big_scraper) { JohnStamos::PinSearch.new(client, big_search_term) }
+
+        it 'limits to 50, the default' do
+          big_scraper.execute!
+          expect(big_scraper.limit).to eq(50)
+        end
+
+        it 'limits the pin_ids collected to 50' do
+          big_scraper.execute!
+          expect(big_scraper.pin_ids.length).to eq(50)
+        end
+      end
+
+      context 'with a limit lower than the default' do
+        subject(:big_scraper_with_small_limit) { JohnStamos::PinSearch.new(client, big_search_term, { limit: 10 }) }
+
+        it 'limits to 10' do
+          expect(big_scraper_with_small_limit.limit).to eq(10)
+        end
+
+        it 'never calls #subsequent_retrieval!' do
+          expect(big_scraper_with_small_limit).to_not receive(:subsequent_retrieval!).with()
+          big_scraper_with_small_limit.execute!
+        end
+
+        it 'collects the correct number of pin_ids' do
+          big_scraper_with_small_limit.execute!
+          expect(big_scraper_with_small_limit.pin_ids.length).to eq(10)
+        end
+      end
+
+      context 'with a limit higher than the default' do
+        subject(:big_scraper_with_limit) { JohnStamos::PinSearch.new(client, big_search_term, { limit: 147 }) }
+
+        it 'limits to 147' do
+          expect(big_scraper_with_limit.limit).to eq(147)
+        end
+
+        it 'collects the correct number of pin_ids' do
+          expect{ big_scraper_with_limit.execute! }.to change{ big_scraper_with_limit.pin_ids.length }.from(0).to(147)
+        end
+      end
+
+    end
+  end
+
+  describe '#pins' do
+    let(:bogus_pinterest_ids) { [1,2] }
+    before(:each) { scraper.pin_ids = bogus_pinterest_ids }
+
+    it 'returns an Array' do
+      expect(scraper.pins).to be_a(Array)
+    end
+
+    it 'contains 50 pins' do
+      expect(scraper.pins).to have_exactly(bogus_pinterest_ids.length).pins
+    end
+  end
+end

data/spec/lib/john_stamos/pin_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe JohnStamos::Pin do
+  subject(:pin) do
+    # Test pin from here: http://pinterest.com/pin/412149803369441273/
+    JohnStamos::Pin.new(client, pinterest_pin_id)
+  end
+
+  let(:pinterest_pin_id) { 412149803369441273 }
+  let(:client) { JohnStamos::Client.new }
+
+  it 'responds to #id' do
+    expect(pin).to respond_to(:id)
+  end
+
+  it 'has the correct id' do
+    expect(pin.id).to eq(pinterest_pin_id)
+  end
+
+  it 'responds to #image' do
+    expect(pin).to respond_to(:image)
+  end
+
+  it 'responds to #description' do
+    expect(pin).to respond_to(:description)
+  end
+
+  it 'responds to #pinner' do
+    expect(pin).to respond_to(:pinner)
+  end
+
+  it 'responds to #board' do
+    expect(pin).to respond_to(:board)
+  end
+
+  it 'responds to #like_count' do
+    expect(pin).to respond_to(:like_count)
+  end
+
+  it 'responds to #repin_count' do
+    expect(pin).to respond_to(:repin_count)
+  end
+
+  it 'responds to #source_url' do
+    expect(pin).to respond_to(:source_url)
+  end
+
+  it 'responds to #url' do
+    expect(pin).to respond_to(:url)
+  end
+
+  it 'has the correct url' do
+    expect(pin.url).to eq("http://pinterest.com/pin/#{pinterest_pin_id}/")
+  end
+
+  it 'responds to #video?' do
+    expect(pin).to respond_to(:video?)
+  end
+
+  describe 'scraped data', :vcr do
+    it 'has the correct image' do
+      expect(pin.image).to eq('http://media-cache-ak0.pinimg.com/originals/ee/39/6e/ee396ebad5cffd3f8f6e83b5fd9f07cb.jpg')
+    end
+
+    it 'has the correct description' do
+      expect(pin.description).to eq('JohnStamosgemPin description')
+    end
+
+    it 'belongs to the correct board' do
+      expect(pin.board).to eq('/johnstamosgem/johnstamosgemboard/')
+    end
+
+    it 'has the correct like_count' do
+      expect(pin.like_count).to eq(1)
+    end
+
+    it 'has the correct repin_count' do
+      expect(pin.repin_count).to eq(0)
+    end
+
+    it 'has the correct source_url' do
+      expect(pin.source_url).to eq('http://johnstamosgem.com/')
+    end
+
+    it 'is not a video' do
+      expect(pin.video?).to be_false
+    end
+
+    describe '#pinner' do
+      it 'returns a Pinner object' do
+        expect(pin.pinner).to be_a(JohnStamos::Pinner)
+      end
+
+      it 'shows my fake account as the owning Pinner' do
+        expect(pin.pinner.username).to eq('johnstamosgem')
+      end
+    end
+  end
+
+end

data/spec/lib/john_stamos/pinner_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe JohnStamos::Pinner, :vcr do
+  let(:client) { JohnStamos::Client.new }
+  let(:pinterest_user) { 'johnstamosgem' } # Test user account from here: http://pinterest.com/johnstamosgem/
+
+  subject(:pinner) { JohnStamos::Pinner.new(client, pinterest_user) }
+
+  describe '#username' do
+    it 'responds to #username' do
+      expect(pinner).to respond_to(:username)
+    end
+
+    it 'returns the correct pinterest username' do
+      expect(pinner.username).to eq(pinterest_user)
+    end
+  end
+
+  describe '#url' do
+    it 'responds to #url' do
+      expect(pinner).to respond_to(:url)
+    end
+
+    it 'returns the correct url for the pinner' do
+      expect(pinner.url).to eq("http://pinterest.com/#{pinterest_user}/")
+    end
+  end
+
+  describe '#pin_count' do
+    it 'responds to #pin_count' do
+      expect(pinner).to respond_to(:pin_count)
+    end
+
+    it 'returns the correct number of pins' do
+      expect(pinner.pin_count).to eq(1)
+    end
+  end
+
+  describe '#about' do
+    it 'responds to #about' do
+      expect(pinner).to respond_to(:about)
+    end
+
+    it 'returns the correct about text' do
+      expect(pinner.about).to eq('This is the johnstamos about content.')
+    end
+  end
+
+  describe '#follower_count' do
+    it 'responds to #follower_count' do
+      expect(pinner).to respond_to(:follower_count)
+    end
+
+    it 'returns a follower count of 0' do
+      expect(pinner.follower_count).to eq(0) # :( I have no friends.
+    end
+  end
+
+  describe '#avatar' do
+    it 'responds to #avatar' do
+      expect(pinner).to respond_to(:avatar)
+    end
+    it 'returns the correct avatar URL' do
+      expect(pinner.avatar).to eq('http://media-cache-ec0.pinimg.com/avatars/johnstamosgem_1375988759_140.jpg')
+    end
+  end
+
+  describe 'name related attributes' do
+    it 'responds to #first_name' do
+      expect(pinner).to respond_to(:first_name)
+    end
+
+    it 'responds to #last_name' do
+      expect(pinner).to respond_to(:last_name)
+    end
+
+    it 'responds to #full_name' do
+      expect(pinner).to respond_to(:full_name)
+    end
+
+    it 'returns the correct first name' do
+      expect(pinner.first_name).to  eq('John')
+    end
+
+    it 'returns the correct last name' do
+      expect(pinner.last_name).to eq('Stamosgem')
+    end
+
+    it 'returns the correct full name' do
+      expect(pinner.full_name).to eq('John Stamosgem')
+    end
+  end
+
+  describe '#board_count' do
+    it 'responds to #board_count' do
+      expect(pinner).to respond_to(:board_count)
+    end
+
+    it 'returns the correct number of boards' do
+      expect(pinner.board_count).to eq(1)
+    end
+  end
+
+  describe '#website_url' do
+    it 'responds to #website_url' do
+      expect(pinner).to respond_to(:website_url)
+    end
+
+    it 'returns the correct website url' do
+      expect(pinner.website_url).to eq('http://johnstamos.com/')
+    end
+  end
+
+  describe '#location' do
+    it 'responds to #location' do
+      expect(pinner).to respond_to(:location)
+    end
+
+    it 'returns the correct location' do
+      expect(pinner.location).to eq('California')
+    end
+  end
+end

data/spec/lib/john_stamos_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe JohnStamos do
+  it "has mercy" do
+    Launchy.should_receive(:open).with('http://www.youtube.com/watch?v=bLqAqIj8Rdc')
+    JohnStamos.send(:uncle_jesse)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'john_stamos'
+require 'john_stamos/pin_search'
+require 'john_stamos/pin'
+require 'john_stamos/pinner'
+require 'john_stamos/client'
+require 'vcr'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/support/vcr_cassettes'
+  c.hook_into :webmock
+  c.default_cassette_options = { :record => :new_episodes }
+  c.configure_rspec_metadata!
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.order = 'random'
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end