yourub 1.1.1 → 2.0.0

data/spec/yourub/count_spec.rb

@@ -0,0 +1,39 @@
+require 'yourub'
+require_relative '../spec_helper.rb'
+
+
+describe Yourub::MetaSearch do
+  describe '#search' do
+    let(:client) { Yourub::Client.new() }
+    let(:result){ double }
+
+    context 'integrates a view count filter' do
+      context 'having a search result with 4 videos with 200 views' do
+        include_context "stub client connection"
+        include_context "search list result load fixture with single video", "search_list.json"
+        context "searching videos with more or equal 200 views" do
+          it 'find 4 videos' do
+            filter = { views: '>= 200' }
+            videos = []
+            client.search(query: "nasa", count_filter: filter, max_results: 2) do |v|
+              videos.push(v)
+            end
+            expect(videos.count).to eq(4)
+          end
+        end
+
+        context "searching videos with more than 200 views" do
+          it 'find 0 video' do
+            filter = { views: '> 200' }
+            videos = []
+            client.search(query: "nasa", count_filter: filter, max_results: 2) do |v|
+              videos.push(v)
+            end
+            expect(videos.count).to eq(0)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/yourub/integration.rb

@@ -0,0 +1,105 @@
+require 'yourub'
+
+#That is an integration test where the client is not stubbed, this test can
+#pass only with an internet connection and a valid developer key. Use this test
+#at the end of your changes, and add new tests if you have added new
+#functionalities. This file is not run in the default spec suite
+describe Yourub::Client do
+
+  context "on initialize" do
+    let(:subject) { Yourub::Client.new }
+
+    before do
+    end
+
+    it "return an error if the given country does not exist" do
+      subject.search(country: "MOON")
+      expect(lambda{subject}).not_to raise_error()
+    end
+
+    it "give me a list of valid countries" do
+      expect(subject.countries).to be_a_kind_of(Array)
+    end
+
+    it "retrieves videos that have more than 100 views" do
+      filter = {views: ">= 100"}
+      videos = []
+      subject.search(country: "US", category: "Sports", count_filter: filter) do |v|
+        videos.push(v)
+      end
+      expect(videos).to_not be_empty
+    end
+
+    it "retrieves videos for all the categories" do
+      videos = []
+      subject.search(country: "US", category: "all") do |v|
+        videos.push(v)
+      end
+      expect(videos).to_not be_empty
+    end
+
+    it "accept an 'order' parameter within the others" do
+      videos = []
+      subject.search(country: "US", category: "Sports", order: 'date') do |v|
+        videos.push(v)
+      end
+      expect(videos).to_not be_empty
+    end
+
+    it "retrieves 5 videos for each given category" do
+      videos = []
+      subject.search(country: "US, DE", category: "Sports", max_results: 5) do |v|
+        videos.push(v)
+      end
+      expect(videos.count).to eq(10)
+    end
+
+    it "retrieves 5 videos for each given category, also if they are passed as array" do
+      videos = []
+      subject.search(country: ["US", "DE"], category: "Sports", max_results: 5) do |v|
+        videos.push(v)
+      end
+      expect(videos.count).to eq(10)
+    end
+
+    it "retrieves the given number of video for the given category" do
+      videos = []
+      subject.search(category: "Sports", max_results: 2) do |v|
+        videos.push(v)
+      end
+      expect(videos.count).to eq(2)
+    end
+
+    it "retrieves the given number of video for the given word" do
+      videos = []
+      subject.search(query: "casa", max_results: 3) do |v|
+        videos.push(v)
+      end
+      expect(videos.count).to eq(3)
+    end
+
+    it "retrieves the given number of video for the given country" do
+      videos = []
+      subject.search(country: "US", max_results: 5) do |v|
+        videos.push(v)
+      end
+      expect(videos.count).to eq(5)
+    end
+
+    # it "retrieves a video for the given id" do
+    #   subject.search(id: "mN0Dbj-xHY0")
+    #   expect(videos.first["id"]).to eql("mN0Dbj-xHY0")
+    # end
+
+    # it "retrieves the view count for given id" do
+    #   expect(subject.get_views("mN0Dbj-xHY0")).to be_a_kind_of(Integer)
+    # end
+
+    # it "return nil for a not existing video" do
+    #   subject.search(id: "fffffffffffffffffffff")
+    #   expect(subject.videos).to be_empty
+    # end
+  end
+
+end
+

data/spec/yourub/meta_search_spec.rb

@@ -0,0 +1,141 @@
+require 'yourub'
+require_relative '../spec_helper.rb'
+
+describe Yourub::MetaSearch do
+  context 'Initialize the Request class if the given parameter are valid' do
+
+    let(:client) { Yourub::Client.new() }
+    # let(:discovered_api) { double("youtube_api")}
+    #let(:discovered_api) { double("youtube_api")}
+    let(:response) {OpenStruct.new(data: {items: [{"statistics" => {"viewCount" => 2}}]}, status: 200)}
+    let(:videos_list_response) { fixture("videos_list.json")}
+    let(:search_list_response) { fixture("search_list.json")}
+    let(:categories_formatted) { fixture("categories_list_formatted.json") }
+    let(:single_video_response) { fixture("video_with_200_views.json") }
+    let(:result){ double }
+
+    before do
+        # discovered_api.stub_chain(:data, :items).and_return(categories)
+        # discovered_api.stub_chain(:search, :list).and_return("search.list")
+        # discovered_api.stub_chain(:video_categories, :list).and_return("video_categories.list")
+        # allow(client).to receive(:youtube_api).and_return(discovered_api)
+        #allow(client).to receive(:execute!).and_return(response)
+        #allow(Yourub::REST::Request).to receive(:new).and_return(response)
+        allow(result).to receive(:status).and_return(200)
+    end
+
+    describe '#search' do
+      context 'forward the parameters to the request' do
+        include_context "search list result load fixture", "search_list.json"
+        before do
+          allow(Yourub::REST::Categories).to receive(
+            :for_country).and_return(categories_formatted)
+          allow(Yourub::REST::Videos).to receive(:list).and_return(response)
+        end
+
+        it 'creates a search list request with the expected parameters' do
+          expect(Yourub::REST::Search).to receive(:list).with(
+                client,
+                {:part => "snippet",
+                 :type => "video",
+                 :order => "date",
+                 :safeSearch => "none",
+                 :category => "Sports",
+                 :maxResults => 5,
+                 :regionCode => "US",
+                 :videoCategoryId => 17}
+          )
+          client.search(
+            country: 'US', category: 'Sports', order: 'date', max_results: 5
+          ) { |v| v }
+        end
+      end
+
+      context 'integrates a view count filter' do
+        include_context 'result load fixture', 'video_with_200_views.json'
+
+        let(:search_result) { double }
+        before do
+          allow(search_result).to receive_message_chain(
+            :data, :items).and_return(search_list_response)
+          search_result.data.items.each do |single_video|
+            allow(single_video).to receive_message_chain(
+            :id, :videoId).and_return(1)
+          end
+
+          allow(Yourub::REST::Search).to receive(:list).and_return(search_result)
+          allow(Yourub::REST::Videos).to receive(:single_video).and_return(result)
+        end
+        it 'retrieves videos that have more than 100 views' do
+          filter = { views: '>= 100' }
+
+          videos = []
+
+          client.search(query: "nasa", count_filter: filter) do |v|
+            videos.push(v)
+          end
+
+          expect(videos.count).to eq(4)
+        end
+
+       it 'retrieves no videos with more than 200 views' do
+          filter = { views: '< 200' }
+
+          videos = []
+
+          client.search(query: "nasa", count_filter: filter ) do |v|
+            videos.push(v)
+          end
+
+          expect(videos.count).to eq(0)
+        end
+
+      end
+
+      # TODO
+      # context 'iterates through the given nation' do
+      #   it "retrieves 5 videos for each given category, also if they are passed as array" do
+      #     videos = []
+      #     subject.search(country: ["US", "DE"], category: "Sports", max_results: 5) do |v|
+      #       videos.push v
+      #     end
+      #     expect(videos.count).to eq(10)
+      #   end
+      # end
+
+      # context 'when the parameter category is == "all"' do
+      #   it 'it iterates through all the categories' do
+      #     videos = []
+      #     client.search(country: 'US', category: 'all') do |v|
+      #       videos.push v
+      #     end
+      #     expect(videos).to_not be_empty
+      #   end
+      # end
+    end
+
+    describe "methods used only for single video" do
+      include_context "result load fixture", "video_with_200_views.json"
+
+      describe '#get' do
+        it 'send the request with the correct parameters' do
+          expect(Yourub::REST::Request).to receive(:new)
+            .with(client, 'videos', 'list', :id => "mN0Dbj-xHY0", :part=>"snippet,statistics")
+          client.get('mN0Dbj-xHY0')
+        end
+      end
+
+      describe '#get_views' do
+        it 'send the request with the correct parameters' do
+          expect(Yourub::REST::Request).to receive(:new)
+            .with(client, 'videos', 'list', :id => "mN0Dbj-xHY0", :part => "statistics")
+          client.get_views('mN0Dbj-xHY0')
+        end
+
+        it 'return the number of view for the given video' do
+          expect(client.get_views('mN0Dbj-xHY0')).to eq(200)
+        end
+      end
+    end
+  end
+end

data/spec/yourub/rest/categories_spec.rb

@@ -0,0 +1,33 @@
+require 'yourub'
+require_relative '../../spec_helper.rb'
+
+describe Yourub::REST::Categories do
+  context 'Initialize the Request class if the given parameter are valid' do
+    let(:category_request)     { double }
+    let(:client)               { Yourub::Client.new }
+    let(:categories)           { fixture('categories_list.json') }
+    let(:categories_formatted) { fixture('categories_list_formatted.json') }
+
+    before do
+      allow(category_request).to receive_message_chain(
+        :data, :items
+      ).and_return(categories)
+      allow(Yourub::REST::Request).to receive(:new).and_return(category_request)
+    end
+
+    describe '.for_country' do
+      it 'create a request with the correct parameters' do
+        expect(Yourub::REST::Request).to receive(:new)
+          .with(client, 'video_categories', 'list',
+                'part' => 'snippet', 'regionCode' => ['US'])
+        subject.for_country(client, ['US'])
+      end
+
+      it 'return an hash containing the id and the title for each category' do
+        expect(subject.for_country(client, ['US'])).to eq(
+          categories_formatted
+        )
+      end
+    end
+  end
+end

data/spec/yourub/rest/request_spec.rb

@@ -0,0 +1,32 @@
+require 'yourub'
+require_relative '../../spec_helper'
+
+describe Yourub::REST::Request do
+  context 'during requests initialization' do
+    include_context "stub client connection"
+    let(:param) { { 'part' => 'snippet', 'regionCode' => 'de' } }
+
+    describe 'the request object calls the execute! method on the client' do
+      it 'execute the video list request on the client' do
+        expect(client).to receive(:execute!).with(
+          api_method: 'video_categories.list', parameters: param
+        )
+        Yourub::REST::Request.new(client, 'video_categories', 'list', param)
+      end
+
+      it 'execute the search list request on the client' do
+        expect(client).to receive(:execute!).with(
+          api_method: 'search.list', parameters: param
+        )
+        Yourub::REST::Request.new(client, 'search', 'list', param)
+      end
+
+      it 'execute the video list request on the client' do
+        expect(client).to receive(:execute!).with(
+          api_method: 'videos.list', parameters: param
+        )
+        Yourub::REST::Request.new(client, 'videos', 'list', param)
+      end
+    end
+  end
+end

data/spec/yourub/rest/videos_spec.rb

@@ -0,0 +1,24 @@
+require 'yourub'
+require_relative '../../spec_helper.rb'
+
+describe Yourub::REST::Videos do
+  context "Initialize the Request class if the given parameter are valid" do
+    let(:video_request) { double }
+    let(:client) { Yourub::Client.new() }
+    let(:videos) { fixture("videos_list.json") }
+
+    before do
+      allow(video_request).to receive_message_chain(:data, :items).and_return(videos)
+      allow(Yourub::REST::Request).to receive(:new).and_return(video_request)
+    end
+
+    describe ".list" do
+      it "create a request with the correct parameters" do
+        expect(Yourub::REST::Request).to receive(:new)
+          .with(client, "videos", "list", {"part"=>"snippet", "regionCode" => ['US']})
+        subject.list(client, {"part"=>"snippet", "regionCode" => ['US']})
+      end
+    end
+  end
+end
+

data/spec/yourub/validator_spec.rb

@@ -3,107 +3,104 @@ require 'yourub'
 describe Yourub::Validator do
   let(:subject) { Yourub::Validator.confirm(criteria) }
 
-  context "passing an hash containing the search criteria" do
-    context "with some valid criteria" do
-
-      context "no matter if the crteria has old 'key' => 'val' or key: val sintax" do
-        let(:criteria) { {"country" => 'US', "category" => 'Sport'} }
-        it "return the criteria in the sym: val format" do
-          expect(subject).to eq({country: ['US'], category: 'Sport'})
+  context 'passing an hash containing the search criteria' do
+    context 'with some valid criteria' do
+      context 'with an old hash syntax' do
+        let(:criteria) { { 'country' => 'US', 'category' => 'Sport' } }
+        it 'return the criteria in the sym: val format' do
+          expect(subject).to eq(country: ['US'], category: 'Sport')
         end
       end
 
-      context "with valid nation but unknown parameter city" do
-        let(:criteria) { {country: 'US', city: 'Berlin'} }
-        it "return criteria including nation but excluding the city" do
-          expect(subject).to eq({country: ['US']})
+      context 'with valid nation but unknown parameter city' do
+        let(:criteria) { { country: 'US', city: 'Berlin' } }
+        it 'return criteria including nation but excluding the city' do
+          expect(subject).to eq(country: ['US'])
         end
       end
 
-      context "with an invalid :order value" do
-        let(:criteria) { {order: 'banane', query: 'roberto baggio'} }
+      context 'with an invalid :order value' do
+        let(:criteria) { { order: 'banane', query: 'roberto baggio' } }
         it 'raise an argument error' do
-          expect(lambda{subject}).to raise_error(ArgumentError)
+          expect(lambda{ subject }).to raise_error(ArgumentError)
         end
       end
 
-      context "with a given category without a country" do
-        let(:criteria) { {country: '', category: 'Sport'} }
-        it "add the default country" do
-          expect(subject).to eq({category: 'Sport', :country=>["US"]})
+      context 'with a given category without a country' do
+        let(:criteria) { { country: '', category: 'Sport' } }
+        it 'add the default country' do
+          expect(subject).to eq(category: 'Sport', :country => ['US'])
         end
       end
 
-      context "with all the available parameters present" do
-        let(:criteria) { {country: 'IT', 
-                          category: 'Sport', 
-                          max_results: 2, 
-                          count_filter: {}, 
-                          query: '', 
-                          id: ''} }
-        it "return only them params that has a value" do
-          expect(subject).to eq({country: ["IT"], category: 'Sport', max_results: 2 })
+      context 'with all the available parameters present' do
+        let(:criteria) do
+          { country: 'IT',
+            category: 'Sport',
+            max_results: 2,
+            count_filter: {},
+            query: ''
+          }
         end
-      end
-
-      context "when the parameter 'id' is set" do
-        let(:criteria) { {country: 'US', id: '1111111111'} }
-        it "ignore the other params and leave only the id" do 
-          expect(subject).to eq({ id: '1111111111' })
+        it 'return only them params that has a value' do
+          expect(subject).to eq(
+            country: ['IT'], category: 'Sport', max_results: 2
+          )
         end
       end
     end
 
-    context "if none of the criteria are valid" do
-      context "with non valid criteria" do
-        let(:criteria) { {big: 1, bang: 2} }
+    context 'if none of the criteria are valid' do
+      context 'with non valid criteria' do
+        let(:criteria) { { big: 1, bang: 2 } }
         it 'raise an argument error' do
-          expect(lambda{subject}).to raise_error(ArgumentError)
+          expect(lambda{ subject }).to raise_error(ArgumentError)
         end
       end
 
-      context "with criteria in the wrong format, like a string" do
-        let(:criteria) { "country = US" }
+      context 'with criteria in the wrong format, like a string' do
+        let(:criteria) { 'country = US' }
         it 'raise an argument error' do
-          expect(lambda{subject}).to raise_error(ArgumentError)
+          expect(lambda{ subject }).to raise_error(ArgumentError)
         end
       end
 
-      context "with an invalid country" do
-        let(:criteria) { {country: 'MOON'} }
+      context 'with an invalid country' do
+        let(:criteria) { { country: 'MOON' } }
         it 'raise an argument error' do
-          expect(lambda{subject}).to raise_error(ArgumentError)
+          expect(lambda{ subject }).to raise_error(ArgumentError)
         end
       end
     end
 
-    context "with valid criteria but not enough to start a search" do
-      context "only with maximum and count filter" do
-        let(:criteria) { {max_results: 10, count_filter: {views: ">= 100"}} }
+    context 'with valid criteria but not enough to start a search' do
+      context 'only with maximum and count filter' do
+        let(:criteria) do
+          { max_results: 10, count_filter: { views: '>= 100' } }
+        end
         it 'raise an argument error' do
-          expect(lambda{subject}).to raise_error(ArgumentError)
+          expect(lambda{ subject }).to raise_error(ArgumentError)
         end
       end
-    end    
+    end
   end
 
-  context "passing a list of available categories and the selected one" do
+  context 'passing a list of available categories and the selected one' do
     let(:subject) { Yourub::Validator.valid_category(categories, selected_one) }
-    let(:categories) { [{"10"=>"music"}, {"15"=>"pets&animals"}, {"17"=>"sports"}, {"18"=>"shortmovies"}] }
+    let(:categories) { [{'10'=>'music'}, {'15'=>'pets&animals'}, {'17'=>'sports'}, {'18'=>'shortmovies'}] }
 
-    context "with an invalid category" do
-      let(:selected_one) { "spaghetti" }
+    context 'with an invalid category' do
+      let(:selected_one) {"spaghetti"}
       it 'raise an argument error' do
         expect(lambda{subject}).to raise_error(ArgumentError)
       end
     end
 
-    context "with a valid category" do
-      let(:selected_one) { "sports" }
+    context 'with a valid category' do
+      let(:selected_one) { 'sports' }
       it 'return it' do
-        expect(subject.first.has_value? "sports").to be_true
+        expect(subject.first.has_value? "sports").to eq true
       end
     end
   end
-
-end
+end

data/yourub.gemspec

@@ -19,11 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'google-api-client', '~> 0.7'
-  spec.add_runtime_dependency "thor" , '~> 0.18'
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "byebug", "~> 3.1"
-  spec.add_development_dependency "rake", "~> 10.1"
-  spec.add_development_dependency "rspec", "~> 2.14"
-  #spec.add_development_dependency "webmock", "~> 1.20"
 
 end