rmd 0.1.1 → 0.1.2

data/spec/rmd/nct/playlist_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe RMD::NCT::Playlist do
-  let(:playlist) { described_class.new(link) }
-  let(:link) { 'www.nhaccuatui.com/bai-hat/playlist.mp3' }
-  let(:element_css) { '.item_content .name_song' }
-
-  it_behaves_like 'RMD::Base::Playlist'
-
-  describe '#fetch' do
-    before do
-      allow(playlist).to receive(:song_elements)
-        .and_return(song_elements)
-    end
-
-    context 'when there are song elements' do
-      let(:element) { double('Element') }
-      let(:errors) { 'errors' }
-      let(:song_link) { 'song_link' }
-      let(:song_elements) { [element, element] }
-      let(:song_1) { instance_double('RMD::NCT::Song', success?: true, fetch: nil, data_link: song_link) }
-      let(:song_2) { instance_double('RMD::NCT::Song', success?: false, fetch: nil, errors: errors) }
-
-      before do
-        allow(element).to receive(:attr).with('href').and_return(link)
-        expect(RMD::NCT::Song).to receive(:new).with(link).and_return(song_1, song_2)
-      end
-
-      it 'fetchs all the song from the playlist' do
-        capture_io { playlist.fetch }
-        expect(playlist.songs).to eq [song_link]
-        expect(playlist.errors).to eq [errors]
-      end
-    end
-
-    context 'when there are no song elements' do
-      let(:song_elements) { [] }
-
-      it 'does not do anything' do
-        playlist.fetch
-        expect(playlist.songs).to eq []
-        expect(playlist.errors).to eq ['Can not get song lists from this playlist page.']
-      end
-    end
-  end
-end

data/spec/rmd/nct/song_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-describe RMD::NCT::Song do
-  let(:song) { described_class.new(link) }
-  let(:link) { 'www.nhaccuatui/bai-hat/song.mp3' }
-
-  describe '#fetch' do
-    let(:data_link) { 'data_link' }
-    let(:errors) { 'errors' }
-    let(:getter_1) { instance_double('RMD::NCT::Getter::KeyFromPage',
-                                   data_link: data_link,
-                                   errors: errors) }
-    let(:getter_2) { instance_double('RMD::NCT::Getter::KeyFromPage',
-                                   data_link: data_link,
-                                   errors: nil) }
-    let(:getter_3) { instance_double('RMD::NCT::Getter::KeyFromPage',
-                                   data_link: data_link,
-                                   errors: errors) }
-    let(:getters) { [getter_1, getter_2, getter_3] }
-
-    it 'fetchs songs' do
-      expect(song).to receive(:getters).and_return(getters)
-      expect(getter_1).to receive(:fetch)
-      expect(getter_2).to receive(:fetch)
-      expect(getter_3).not_to receive(:fetch)
-      song.fetch
-    end
-  end
-
-  describe '#success?' do
-    subject { song.success? }
-
-    before do
-      allow(song).to receive(:data_link).and_return(data_link)
-    end
-
-    context 'when datalink is present' do
-      let(:data_link) { 'data_link' }
-      it { is_expected.to eq true }
-    end
-
-    context 'when datalink is not present' do
-      let(:data_link) { nil }
-      it { is_expected.to eq false }
-    end
-  end
-
-  describe '#getters' do
-    let(:getters) { song.send(:getters) }
-    let(:getter_classes) { getters.map(&:class) }
-
-    it 'contains getter' do
-      expect(getter_classes).to include(RMD::NCT::Getter::KeyFromUrl)
-      expect(getter_classes).to include(RMD::NCT::Getter::KeyFromPage)
-    end
-  end
-end

data/spec/rmd/processor_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe RMD::Processor do
-  let(:processor) { described_class.new(link) }
-  let(:link) { 'www.example/xyz/abc.mp3' }
-
-  describe '.process' do
-    let(:link) { 'www.example/xyz/abc.mp3' }
-    let(:processor) { double('RMD::processor') }
-
-    it 'processes' do
-      expect(described_class).to receive(:new).with(link, {}).and_return(processor)
-      expect(processor).to receive(:process)
-      described_class.process(link)
-    end
-  end
-
-  describe '#process' do
-    let(:errors) { ['errors'] }
-    let(:songs) { [song] }
-    let(:song) { 'song.mp3' }
-    let(:playlist) { instance_double('RMD::NCT::Playlist', songs: songs,
-                                     errors: errors,
-                                     success?: success) }
-
-    before do
-      expect(RMD::Factory).to receive(:build).with(link).and_return(playlist)
-      expect(playlist).to receive(:fetch)
-    end
-
-    context 'when fetching songs is success' do
-      let(:success) { true }
-
-      it 'downloads the songs' do
-        expect(processor).to receive(:download).with(song)
-        expect {
-          processor.process
-        }.to output("\e[0;32;49mStart processing #{link}...\e[0m\n\e[0;31;49merrors\e[0m\n").to_stdout
-      end
-    end
-
-    context 'when fetching songs is not success' do
-      let(:success) { false }
-
-      it 'does not download the songs' do
-        expect(processor).not_to receive(:download)
-        expect {
-          processor.process
-        }.to output("\e[0;32;49mStart processing #{link}...\e[0m\n\e[0;31;49merrors\e[0m\n").to_stdout
-      end
-    end
-  end
-
-  describe '#download' do
-    let(:data_link) { 'data_link' }
-
-    it 'downloads data' do
-      expect(RMD::Downloader).to receive(:download).with(data_link, {})
-      processor.send(:download, data_link)
-    end
-  end
-end

data/spec/rmd/song_playlist_adapter_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe RMD::SongPlaylistAdapter do
-  let(:adapter) { described_class.new(song) }
-
-  describe '#songs' do
-    let(:song) { instance_double('RMD::NCT::Song', data_link: data_link) }
-    subject { adapter.songs }
-
-    context 'when song has the link' do
-      let(:data_link) { 'data_link' }
-      it { is_expected.to eq [data_link] }
-    end
-
-    context 'when song does not have the link' do
-      let(:data_link) { nil }
-      it { is_expected.to eq [] }
-    end
-  end
-
-  describe '#errors' do
-    let(:song) { instance_double('RMD::NCT::Song', errors: errors) }
-    subject { adapter.errors }
-
-    context 'when song has the error' do
-      let(:errors) { 'errors' }
-      it { is_expected.to eq [errors] }
-    end
-
-    context 'when song does not have the error' do
-      let(:errors) { nil }
-      it { is_expected.to eq [] }
-    end
-  end
-end

data/spec/rmd/zing/playlist_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe RMD::Zing::Playlist do
-  let(:playlist) { described_class.new(link) }
-  let(:link) { 'mp3.zing.vn/bai-hat/playlist.mp3' }
-  let(:element_css) { '._btnDownload' }
-
-  it_behaves_like 'RMD::Base::Playlist'
-
-  describe '#fetch' do
-    before do
-      allow(playlist).to receive(:song_elements)
-        .and_return(song_elements)
-    end
-
-    context 'when there are song elements' do
-      let(:element) { double('Element') }
-      let(:errors) { 'errors' }
-      let(:song_link) { 'song_link' }
-      let(:song_elements) { [element] }
-
-      before do
-        expect(element).to receive(:attr).with('href').and_return(link)
-        expect(RMD::Zing::Utils::CorrectUrl).to receive(:correct).with(link).and_return(song_link)
-      end
-
-      it 'fetchs all the song from the playlist' do
-        capture_io { playlist.fetch }
-        expect(playlist.songs).to eq [song_link]
-        expect(playlist.errors).to eq []
-      end
-    end
-
-    context 'when there are no song elements' do
-      let(:song_elements) { [] }
-
-      it 'does not do anything' do
-        playlist.fetch
-        expect(playlist.songs).to eq []
-        expect(playlist.errors).to eq ['Can not get song lists from this playlist page.']
-      end
-    end
-  end
-end

data/spec/rmd/zing/song_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-
-describe RMD::Zing::Song do
-  let(:link) { 'mp3.zing.vn/bai-hat/abc.mp3' }
-  let(:song) { described_class.new(link) }
-
-  describe '#fetch' do
-    before do
-      expect(song).to receive(:new_link)
-        .and_return(new_link).at_least(:once)
-    end
-
-    context 'when new link exists' do
-      let(:new_link) { 'mp3.zing.vn' }
-      let(:data_link) { 'mp3.zing.vn/data/mp3' }
-
-      before do
-        expect(RMD::Zing::Utils::CorrectUrl).to receive(:correct)
-          .with(new_link).and_return(data_link)
-      end
-
-      it 'returns correct new link' do
-        song.fetch
-        expect(song.data_link).to eq data_link
-        expect(song.errors).to be_nil
-      end
-    end
-
-    context 'when new link does not exist' do
-      let(:new_link) { nil }
-
-      it 'returns error' do
-        song.fetch
-        expect(song.data_link).to eq nil
-        expect(song.errors).to eq 'Can not get song from this link!'
-      end
-    end
-  end
-
-  describe '#new_link' do
-    let(:page) { double('Page') }
-    let(:elements) { [element] }
-    let(:element) { double('Element', text: text) }
-    subject { song.send(:new_link) }
-
-    before do
-      expect(song).to receive(:page).and_return(page)
-      expect(page).to receive(:search).with('.detail-function script').and_return(elements)
-    end
-
-    context 'when match data exists' do
-      let(:text) { 'abc http://mp3.zing.vn/download/song/abc/xyz' }
-      it { is_expected.to eq 'http://mp3.zing.vn/download/song/abc/xyz' }
-    end
-
-    context 'when match data is not exists' do
-      let(:text) { 'abc http://mp3.zing.vn' }
-      it { is_expected.to eq nil }
-    end
-  end
-
-  describe '#page' do
-    let(:agent) { instance_double('Mechanize') }
-    let(:page) { double('Page') }
-    subject { song.send(:page) }
-
-    before do
-      expect(song).to receive(:agent).and_return(agent)
-      expect(agent).to receive(:get).with(link).and_return(page)
-    end
-
-    it { is_expected.to eq page }
-  end
-
-  describe '#success?' do
-    subject { song.success? }
-
-    before do
-      allow(song).to receive(:data_link).and_return(data_link)
-    end
-
-    context 'when datalink is present' do
-      let(:data_link) { 'data_link' }
-      it { is_expected.to eq true }
-    end
-
-    context 'when datalink is not present' do
-      let(:data_link) { nil }
-      it { is_expected.to eq false }
-    end
-  end
-end

data/spec/rmd/zing/utils/correct_url_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe RMD::Zing::Utils::CorrectUrl do
-  describe '#correct' do
-    let(:util) { described_class.new(url) }
-
-    context 'when url is normal' do
-      let(:url) { 'http://www.nhaccuatui.com/download/song/tFBwsJKDGQX9' }
-
-      it 'returns that url' do
-        VCR.use_cassette('utils correct_url correct') do
-          expect(util.correct).to eq url
-        end
-      end
-    end
-
-    context 'when url is a redirect' do
-      let(:url) { 'http://mp3.zing.vn/download/song/Bird-TV-Size-Yuya-Matsushita/ZHJntZGsBidFQQQTLDxyDHkG' }
-      let(:redirect_url) { 'http://dl2.mp3.zdn.vn/fsdd1131lwwjA/74548e9982bf8c91fdbf7939139a5bb0/54ba2490/2011/06/05/d/f/dfed7ed9a9ed91387af6062db606e72f.mp3?filename=Bird%20TV%20Size%20-%20Yuya%20Matsushita.mp3' }
-
-      it 'returns that url' do
-        VCR.use_cassette('utils correct_url redirect') do
-          expect(util.correct).to eq redirect_url
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,124 +0,0 @@
-# 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.
-#
-# 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.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-require 'byebug'
-require 'webmock/rspec'
-require 'vcr'
-require 'simplecov'
-require 'coveralls'
-require 'rmd'
-Dir[__dir__ + '/support/**/*.rb'].each { |f| require f }
-
-Coveralls.wear!
-SimpleCov.start
-
-VCR.configure do |config|
-  config.cassette_library_dir = "fixtures/vcr_cassettes"
-  config.hook_into :webmock
-end
-
-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
-
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-=begin
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Limits the available syntax to the non-monkey patched syntax that is recommended.
-  # For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  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
-end
-
-def capture_io(&block)
-  original_stdout = $stdout
-  original_progressbar_stdout = ProgressBar::Output::DEFAULT_OUTPUT_STREAM
-  $stdout = fake = StringIO.new
-  redef_without_warning(ProgressBar::Output, 'DEFAULT_OUTPUT_STREAM', $stdout)
-  begin
-    yield
-  ensure
-    redef_without_warning(ProgressBar::Output, 'DEFAULT_OUTPUT_STREAM', original_progressbar_stdout)
-    $stdout = original_stdout
-  end
-  fake.string
-end
-
-def redef_without_warning(klass, const, value)
-  klass.send(:remove_const, const) if klass.const_defined?(const)
-  klass.const_set(const, value)
-end