download_tv 2.6.6 → 2.6.7

data/lib/download_tv/torrent.rb

@@ -4,26 +4,49 @@ module DownloadTV
   ##
   # Class in charge of managing the link grabbers
   class Torrent
-    attr_reader :g_instances, :tries
+    class << self
+      def grabbers
+        %w[TorrentAPI Torrentz Eztv]
+      end
 
-    def grabbers
-      %w[TorrentAPI Torrentz Eztv]
+      def healthcheck
+        grabbers.each do |g|
+          grabber = (DownloadTV.const_get g).new
+          puts "#{g}: #{grabber.online? ? 'online' : 'offline'}"
+        end
+      end
     end
 
     def initialize(default_grabber = nil)
-      g_names = grabbers
-
-      # Silently ignores bad names
-      found_default = g_names.find_index(default_grabber)
-      g_names.rotate! found_default if found_default
-
-      @g_instances = g_names.map { |g| (DownloadTV.const_get g).new }
+      @g_instances = self.class.grabbers\
+        .rotate(self.class.grabbers.find_index(default_grabber) || 0)
+        .map { |g| (DownloadTV.const_get g).new }
       reset_tries
 
-      check_grabber_online
+      remove_grabber_if_offline
     end
 
-    def check_grabber_online
+    def get_links(show)
+      @g_instances.first.get_links(show)
+    rescue NoTorrentsError
+      if @tries.positive?
+        change_grabbers
+        retry
+      end
+      # We're out of grabbers to try
+      puts "No torrents found for #{show}"
+      []
+    ensure
+      reset_grabbers_order
+    end
+
+    private
+
+    ##
+    # This method removes the grabber from the instances list if it is not online
+    # It will repeat until it finds an online grabber, or  exit the application
+    # if there are none
+    def remove_grabber_if_offline
       if @g_instances.empty?
         warn 'There are no available grabbers.'
         exit 1
@@ -34,27 +57,13 @@ module DownloadTV
       warn "Problem accessing #{@g_instances.first.class.name}"
       @tries -= 1
       @g_instances.shift # Removes first element
-      check_grabber_online
+      remove_grabber_if_offline
     end
 
     def change_grabbers
       @tries -= 1
       @g_instances.rotate!
-      check_grabber_online
-    end
-
-    def get_links(show)
-      @g_instances.first.get_links(show)
-    rescue NoTorrentsError
-      if @tries.positive?
-        change_grabbers
-        retry
-      end
-      # We're out of grabbers to try
-      puts "No torrents found for #{show}"
-      []
-    ensure
-      reset_grabbers_order
+      remove_grabber_if_offline
     end
 
     def reset_tries

data/lib/download_tv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DownloadTV
-  VERSION = '2.6.6'
+  VERSION = '2.6.7'
 end

data/spec/download_tv/configuration_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+describe DownloadTV::Configuration do
+  let(:raw_config) { double('raw_config') }
+  let(:parsed_config) { { version: DownloadTV::VERSION, pending: [] } }
+  let(:opts) { {} }
+  subject { described_class.new(opts) }
+
+  before :each do
+    allow(File).to receive(:exist?).and_return true
+    allow(File).to receive(:read).and_return raw_config
+    allow(JSON).to receive(:parse).and_return parsed_config
+  end
+
+  describe '#[] and #[]=' do
+    it 'will set and get values of the underlying hash' do
+      subject[:test] = :any
+      expect(subject[:test]).to eq(:any)
+    end
+  end
+
+  describe '#initialize' do
+    context 'when the config file exists' do
+      context 'when options are given' do
+        let(:opts) { { myepisodes_user: 'test', pending: [1], ignored: ['aAAa'] } }
+        it 'will apply them to the final config' do
+          expect(subject[:myepisodes_user]).to eq opts[:myepisodes_user]
+          expect(subject[:pending]).to eq opts[:pending]
+        end
+
+        it 'will downcase strings in :ignored' do
+          expect(subject[:ignored].first).to eq opts[:ignored].first.downcase
+        end
+      end
+    end
+
+    context 'when the config file does not exist' do
+      before :each do
+        allow(File).to receive(:exist?).and_return false
+        allow(FileUtils).to receive(:mkdir_p)
+        allow_any_instance_of(described_class).to receive(:change_configuration)
+        allow_any_instance_of(described_class).to receive(:serialize)
+      end
+
+      context 'when options are given' do
+        let(:opts) { { myepisodes_user: 'test' } }
+
+        it 'will override the other values' do
+          expect(subject[:myepisodes_user]).to eq opts[:myepisodes_user]
+        end
+      end
+    end
+  end
+
+  describe '#change_configuration' do
+    let(:myepisodes_user) { 'myep' }
+    let(:cookies) { 'n' }
+    let(:ignored) { 'ignored1,ignored2' }
+
+    before :each do
+      allow(File).to receive(:exist?).and_return false
+      allow(FileUtils).to receive(:mkdir_p)
+      allow_any_instance_of(described_class).to receive(:serialize)
+      allow($stdin).to receive(:gets).and_return(myepisodes_user, cookies, ignored, '', '')
+    end
+
+    it 'will create a new config with the given and the default values' do
+      expect(subject[:myepisodes_user]).to eq myepisodes_user
+      expect(subject[:cookie]).to be false
+      expect(subject[:auto]).to be true
+      expect(subject[:ignored].size).to eq 2
+      expect(subject[:date]).to eq(Date.today - 1)
+      expect(subject[:filters]).not_to be_nil
+      expect(subject[:version]).not_to be_nil
+      expect(subject[:pending]).not_to be_nil
+      expect(subject[:grabber]).not_to be_nil
+    end
+  end
+
+  describe '#serialize' do
+    let(:parsed_config) { { version: DownloadTV::VERSION, pending: [1, 1, 2] } }
+
+    before :each do
+      allow(File).to receive(:write).and_return nil
+    end
+
+    it 'will remove duplicates from :pending' do
+      subject.serialize
+      expect(subject[:pending].size).to eq 2
+    end
+
+    it 'will write to a file' do
+      expect(File).to receive(:write)
+      subject.serialize
+    end
+
+    context 'when a path is given in the options' do
+      let(:opts) { { path: '/tmp/test' } }
+      it 'will write to a file in our given path' do
+        config = double('config')
+        expect(JSON).to receive(:generate).and_return(config)
+        expect(File).to receive(:write).with(opts[:path], config)
+        subject.serialize
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'will form a string with each (key, value) pair in a new line' do
+      expected = "version: #{DownloadTV::VERSION}\n"\
+        "pending: []\n"
+      expect(subject.to_s).to eq expected
+    end
+  end
+
+  describe '#clear_pending' do
+    it 'will clear :pending and call serialize' do
+      subject[:pending] << double
+      expect(subject).to receive(:serialize)
+      expect(subject[:pending].size).to eq 1
+      subject.clear_pending
+      expect(subject[:pending].size).to eq 0
+    end
+  end
+
+  describe '#queue_pending' do
+    it 'will add an item to :pending and serialize' do
+      expect(subject).to receive(:serialize)
+      expect(subject[:pending].size).to eq 0
+      subject.queue_pending(double)
+      expect(subject[:pending].size).to eq 1
+    end
+  end
+
+  context 'breaking changes:' do
+    let(:version) { nil }
+    let(:parsed_config) do
+      {
+        version: version
+      }
+    end
+
+    before :each do
+      stub_const('DownloadTV::VERSION', '2.1.10')
+      allow(File).to receive(:exist?).and_return true
+      allow(File).to receive(:read).and_return raw_config
+      allow(JSON).to receive(:parse).and_return parsed_config
+    end
+
+    describe 'when the config does not have a version' do
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+
+    describe 'when the app version is newer (patch)' do
+      let(:version) { '2.1.9' }
+      it 'will NOT trigger a config update' do
+        expect_any_instance_of(described_class).not_to receive(:change_configuration)
+        subject
+      end
+    end
+
+    describe 'when the app version is the same' do
+      let(:version) { '2.1.10' }
+      it 'will NOT trigger a config update' do
+        expect_any_instance_of(described_class).not_to receive(:change_configuration)
+        subject
+      end
+    end
+
+    describe 'when the app version is newer (minor)' do
+      let(:version) { '2.0.19' }
+
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+
+    describe 'when the app version is newer (major)' do
+      let(:version) { '1.20.999' }
+
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+
+    describe 'when the app version is older (any)' do
+      let(:version) { '2.1.11' }
+      it 'will trigger a config update' do
+        expect_any_instance_of(described_class).to receive(:change_configuration).once.and_return nil
+        subject
+      end
+    end
+  end
+end

data/spec/download_tv/filterer_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+describe DownloadTV::Filterer do
+  let(:excludes) { [] }
+  let(:includes) { [] }
+  let(:filters_config) { { excludes: excludes, includes: includes } }
+
+  subject { described_class.new(filters_config) }
+
+  describe '#filter' do
+    let(:test_data) do
+      [
+        'Test 12',
+        'Test 10',
+        'Exclude'
+      ]
+    end
+
+    context 'when there are no filters' do
+      it 'will return the given list' do
+        expect(subject.filter(test_data)).to eq test_data
+      end
+    end
+
+    context 'when there are exclude filters' do
+      describe 'when there is only one entry not matching (one filter)' do
+        let(:excludes) { ['TEST'] }
+        it 'will return it' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 1
+          expect(filtered.first).to eq 'Exclude'
+        end
+      end
+
+      describe 'when there is only one entry not matching (multiple filter)' do
+        let(:excludes) { ['2', '0'] }
+        it 'will return it' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 1
+          expect(filtered.first).to eq 'Exclude'
+        end
+      end
+
+      describe 'when only one filter matches' do
+        let(:excludes) { ['0'] }
+        it 'will not return that element' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 2
+          expect(filtered.include?('Test 10')).to be false
+        end
+      end
+
+      describe 'when no entries match' do
+        let(:excludes) { ['zzzz'] }
+        it 'will return the original' do
+          filtered = subject.filter(test_data)
+          expect(filtered).to eq test_data
+        end
+      end
+
+      describe 'when all entries match (one filter)' do
+        let(:excludes) { ['E'] }
+        it 'will return the original' do
+          filtered = subject.filter(test_data)
+          expect(filtered).to eq test_data
+        end
+      end
+
+      describe 'when all entries match (more filters)' do
+        let(:excludes) { ['TEST', 'EXCLUDE'] }
+        it 'will only apply filters until there would be no values left' do
+          filtered = subject.filter(test_data)
+          expect(filtered.size).to eq 1
+          expect(filtered.first).to eq 'Exclude'
+        end
+      end
+    end
+
+    context 'when there are include filters' do
+      let(:includes) { ['TEST'] }
+      it 'will filter out entries not matching' do
+        filtered = subject.filter(test_data)
+        expect(filtered.size).to eq 2
+        expect(filtered.include?('Exclude')).to be false
+      end
+    end
+
+    context 'when there are both types of filters' do
+      let(:excludes) { ['EXCLUDE'] }
+      let(:includes) { ['EXCLUDE'] }
+
+      it 'will apply "includes" filters first' do
+        filtered = subject.filter(test_data)
+        expect(filtered.size).to eq 1
+        expect(filtered.first).to eq 'Exclude'
+      end
+
+      describe 'if the filters are not capitalised' do
+        let(:excludes) { ['exclude'] }
+        let(:includes) { ['test'] }
+        it 'will not apply the filter successfully' do
+          expect(subject.filter(test_data)).to eq test_data
+        end
+      end
+    end
+  end
+end

data/spec/download_tv/linkgrabber_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+describe DownloadTV::LinkGrabber do
+  # TODO: Write specs for the individual grabbers (see #4)
+  # grabbers = DownloadTV::Torrent.grabbers
+  # instances = grabbers.map { |g| (DownloadTV.const_get g).new }
+
+  # instances.each do |grabber|
+  #   describe grabber do
+  #   end
+  # end
+
+  it "raises an error if the instance doesn't implement get_links" do
+    expect { DownloadTV::LinkGrabber.new(double).get_links(double) }.to raise_error(NotImplementedError)
+  end
+end

data/spec/download_tv/myepisodes_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+describe DownloadTV::MyEpisodes do
+  let(:save_cookie) { true }
+  let(:page) { double('page') }
+  let(:agent) { double('agent', :user_agent= => nil, get: page) }
+  let(:cookie_jar) { double('cookie_jar') }
+  subject { described_class.new('user', true) }
+
+  before :each do
+    allow(Mechanize).to receive(:new).and_return agent
+    allow(agent).to receive(:cookie_jar).and_return cookie_jar
+    allow(cookie_jar).to receive(:load)
+    allow(cookie_jar).to receive(:save)
+  end
+
+  describe '#initialize' do
+    context 'when cookie does not load' do
+      it 'will execute a user/password login' do
+        allow_any_instance_of(described_class).to receive(:load_cookie).and_return false
+        expect_any_instance_of(described_class).to receive(:manual_login).once.and_return nil
+        subject
+      end
+    end
+
+    context 'when using a valid cookie' do
+      it 'will log in via cookie' do
+        allow_any_instance_of(described_class).to receive(:load_cookie).and_return true
+        expect_any_instance_of(described_class).not_to receive(:manual_login)
+        subject
+      end
+    end
+  end
+
+  describe '#get_shows_since' do
+    # TODO
+  end
+end

data/spec/download_tv/torrent_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+describe DownloadTV::Torrent do
+  let(:default_grabber) { nil }
+  let(:eztv_mock) { double('eztv') }
+  let(:torrentapi_mock) { double('torrentapi') }
+  let(:torrentz_mock) { double('torrentz') }
+  let(:tpb_mock) { double('tpb') }
+  let(:test_show) { double('test_show') }
+  subject { described_class.new(default_grabber) }
+
+  before :each do
+    allow(DownloadTV::TorrentAPI).to receive(:new).and_return torrentapi_mock
+    allow(DownloadTV::Torrentz).to receive(:new).and_return torrentz_mock
+    allow(DownloadTV::Eztv).to receive(:new).and_return eztv_mock
+    # allow(DownloadTV::ThePirateBay).to receive(:new).and_return tpb_mock
+
+    allow(torrentapi_mock).to receive(:online?).and_return(true)
+    allow(torrentz_mock).to receive(:online?).and_return(true)
+    allow(eztv_mock).to receive(:online?).and_return(true)
+  end
+
+  describe 'Torrent.grabbers' do
+    it 'returns the list of grabbers' do
+      # This order is assumed in the other specs, so explicitly checking it here
+      expect(described_class.grabbers).to eq %w[TorrentAPI Torrentz Eztv]
+
+    end
+  end
+
+  describe '#get_links' do
+    it 'will use the first grabber and return its #get_link result' do
+      result = double('result')
+      expect(torrentapi_mock).to receive(:get_links).with(test_show).and_return(result)
+
+      result = subject.get_links(test_show)
+    end
+
+    context 'when the first grabber is offline' do
+      before do
+        allow(torrentapi_mock).to receive(:online?).and_return(false)
+      end
+
+      it 'will use the second grabber' do
+        expect(torrentapi_mock).not_to receive(:get_links)
+        expect(eztv_mock).not_to receive(:get_links)
+        expect(torrentz_mock).to receive(:get_links).with(test_show)
+
+        result = subject.get_links(test_show)
+      end
+    end
+
+    context 'when all the grabbers are offline' do
+      before do
+        allow(torrentapi_mock).to receive(:online?).and_return(false)
+        allow(torrentz_mock).to receive(:online?).and_return(false)
+        allow(eztv_mock).to receive(:online?).and_return(false)
+      end
+
+      it 'will exit' do
+        expect(torrentapi_mock).not_to receive(:get_links)
+        expect(torrentz_mock).not_to receive(:get_links)
+        expect(eztv_mock).not_to receive(:get_links)
+
+        expect { subject.get_links(test_show) }.to raise_error(SystemExit)
+      end
+    end
+
+    context 'when one grabber does not find a link' do
+      before do
+        allow(torrentapi_mock).to receive(:get_links).with(test_show).and_raise(DownloadTV::NoTorrentsError)
+        allow(torrentz_mock).to receive(:get_links).with(test_show).and_raise(DownloadTV::NoTorrentsError)
+      end
+
+      it 'will keep trying until one does' do
+        expect(torrentapi_mock).to receive(:get_links).ordered
+        expect(torrentz_mock).to receive(:get_links).ordered
+        expect(eztv_mock).to receive(:get_links).ordered
+
+        result = subject.get_links(test_show)
+      end
+    end
+
+    context 'when no grabber can find a link' do
+      before do
+        allow(torrentapi_mock).to receive(:get_links).with(test_show).and_raise(DownloadTV::NoTorrentsError)
+        allow(torrentz_mock).to receive(:get_links).with(test_show).and_raise(DownloadTV::NoTorrentsError)
+        allow(eztv_mock).to receive(:get_links).with(test_show).and_raise(DownloadTV::NoTorrentsError)
+      end
+
+      it 'will return an empty array' do
+        expect(torrentapi_mock).to receive(:get_links).ordered
+        expect(torrentz_mock).to receive(:get_links).ordered
+        expect(eztv_mock).to receive(:get_links).ordered
+
+        expect(subject.get_links(test_show)).to eq []
+      end
+    end
+
+    context 'when the default grabber is set' do
+      let(:default_grabber) { 'Eztv' }
+
+      it 'will use that grabber preferently' do
+        test_show = double('test_show')
+        expect(torrentapi_mock).not_to receive(:get_links)
+        expect(torrentz_mock).not_to receive(:get_links)
+        expect(eztv_mock).to receive(:get_links).with(test_show)
+
+        result = subject.get_links(test_show)
+      end
+    end
+
+    context 'when a grabber fails on a run and it is called twice' do
+      before do
+        count = 0
+        allow(torrentapi_mock).to receive(:get_links).exactly(2).times.with(test_show) do
+          count += 1
+          raise DownloadTV::NoTorrentsError if count == 1
+        end
+
+      end
+
+      it 'the second run will use the original order' do
+        expect(torrentapi_mock).to receive(:get_links).exactly(2).times
+        expect(torrentz_mock).to receive(:get_links).exactly(1).time
+
+        result = subject.get_links(test_show)
+        result = subject.get_links(test_show)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+require 'download_tv'
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  # config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://relishapp.com/rspec/rspec-core/docs/configuration/zero-monkey-patching-mode
+  # config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  # config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  # if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    # config.default_formatter = "doc"
+  # end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  # config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  # Kernel.srand config.seed
+end