betforker 1.0.1

data/spec/config_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+RSpec.describe Betforker::Config do
+  describe '.update' do
+    before do
+      $config = { a: 'cc', b: 10, c: true }
+      allow(Config).to receive(:manual_enter).and_return(
+	{ a: 'aa', b: 15, c: false })
+      allow(Config).to receive(:write_personal_config).and_return nil
+    end
+
+    it 'user can update config' do
+      values = Config.manual_enter
+      Config.update_config values
+
+      expect($config.size).to eq 3
+      expect($config.keys).to eq [:a, :b, :c]
+      expect($config.values).to eq ['aa', 15, false]
+    end
+  end
+
+  describe '.check_personal_configuration' do
+    let!(:template) do
+      { a: 'aa',
+	b: true,
+	c: false,
+	d: 10,
+	e: 1.0,
+	f: [1,2,3] }
+    end
+    let!(:personal) { template.dup }
+
+    before do
+      allow(Config).to receive(:write_personal_config).and_return nil
+    end
+
+    it 'personal config equal template' do
+      result = Config.check_personal_configuration(template, personal)
+
+      expect(result).to eq personal
+      expect(result.keys).to eq template.keys
+    end
+
+    it 'personal config have other valid values with the same keys' do
+      personal[:a] = 'aaaa'
+      personal[:b] = false
+      personal[:c] = true
+      personal[:d] = 1
+      personal[:e] = 10.0
+      personal[:f] = [1]
+      result = Config.check_personal_configuration(template, personal)
+
+      expect(result).to eq personal
+      expect(result.keys).to eq template.keys
+    end
+
+    it 'personal config have other invalid values with the same keys' do
+      personal[:a] = false
+      personal[:b] = 'aaaa'
+      personal[:c] = 10
+      personal[:d] = 1.0
+      personal[:e] = true
+      personal[:f] = 'bbbb'
+      result = Config.check_personal_configuration(template, personal)
+
+      expect(result).to eq template
+      expect(result.keys).to eq template.keys
+    end
+
+    context 'in personal config keys in other order' do
+      it 'with same values' do
+	personal = {}
+	template.reverse_each { |k, v| personal[k] = v }
+	result = Config.check_personal_configuration(template, personal)
+
+	expect(result).to eq personal
+	expect(result.keys).to eq template.keys
+	expect(result.keys).to_not eq personal.keys
+      end
+
+      it 'with unique values' do
+	personal = {}
+	personal[:f] = [1,2]
+	personal[:e] = 10.0
+	personal[:d] = 1
+	personal[:c] = true
+	personal[:b] = false
+	personal[:a] = 'bb'
+	result = Config.check_personal_configuration(template, personal)
+
+	expect(result).to eq personal
+	expect(result.keys).to eq template.keys
+	expect(result.keys).to_not eq personal.keys
+      end
+    end
+
+    context 'personal config has not enough keys and values' do
+      it 'with same order' do
+	template[:g] = true
+	template[:h] = false
+	result = Config.check_personal_configuration(template, personal)
+
+	expect(result.keys).to eq template.keys
+	expect(result.keys.count).to eq (personal.keys.count + 2)
+	expect(result.values).to eq ((personal.values << true) << false)
+      end
+
+      it 'with other order' do
+	reversed_template = {}
+	reversed_template[:g] = true
+	template.reverse_each { |k, v| reversed_template[k] = v }
+	result = Config.check_personal_configuration(reversed_template, personal)
+
+	expect(result.keys).to eq reversed_template.keys
+	expect(result.keys.count).to eq (personal.keys.count + 1)
+	expect(result[:g]).to eq true
+	personal.each do |key, value|
+	  expect(result[key]).to eq value
+	end
+      end
+    end
+  end
+
+  describe '.same_typeofs' do
+    it 'strings' do
+      a, b = [String, String]
+      expect(Config.same_typeofs(a, b)).to be_truthy
+    end
+
+    it 'fixnums' do
+      a, b = [Fixnum, Fixnum]
+      expect(Config.same_typeofs(a, b)).to be_truthy
+    end
+
+    it 'floats' do
+      a, b = [Float, Float]
+      expect(Config.same_typeofs(a, b)).to be_truthy
+    end
+
+    it 'floats and fixnums' do
+      a, b = [Float, Fixnum]
+      expect(Config.same_typeofs(a, b)).to be_falsey
+    end
+
+    it 'true and false' do
+      a, b = [TrueClass, FalseClass]
+      expect(Config.same_typeofs(a, b)).to be_truthy
+    end
+
+    it 'false and true' do
+      a, b = [FalseClass, TrueClass]
+      expect(Config.same_typeofs(a, b)).to be_truthy
+    end
+  end
+end

data/spec/downloader_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+RSpec.describe Betforker::Downloader do
+  describe '#download_live_page' do
+    before do
+      $config  = { log: false }
+    end
+
+    it 'for marathon properly' do
+      allow(Downloader).to receive(:download_from_marathon).
+	and_return open_right_live_page 'marathon'
+      marathon_live_page = Downloader.download_live_page 'Marathon'
+      page = Nokogiri::HTML(marathon_live_page)
+      login_attr = page.css('#auth').attribute('action').text
+      script_with_data = page.css('script').find {|s| s.text.include? 'initData'}.text
+
+      expect(page.text.size).to be > 1024
+      expect(login_attr).to include ':443/en/login.htm'
+      expect(page.title).to include 'betting odds'
+      expect(script_with_data).to include '"oddsType":"Decimal"'
+      expect(script_with_data).to include '"locale_name":"en"'
+    end
+
+    it 'for williamhill properly' do
+      allow(Downloader).to receive(:download_from_williamhill).
+	and_return open_right_live_page 'williamhill'
+      williamhill_live_page = Downloader.download_live_page 'WilliamHill'
+      page = Nokogiri::HTML(williamhill_live_page)
+      login_text = page.css('#login').text
+      script_with_data = page.css('script').find {|s| s.text.include? 'flashvars'}.text
+
+      expect(page.text.size).to be > 1024
+      expect(login_text).to include 'Join Now'
+      expect(script_with_data).to include 'priceFormat: "decimal"'
+      expect(script_with_data).to include 'WilliamHill'
+    end
+    
+    it 'block from provider' do
+      allow(Downloader).to receive(:download_from_marathon).
+	and_return page_from_provider
+      
+      expect { Downloader.download_live_page 'Marathon' }.to raise_error OpenSSL::SSL::SSLError
+    end
+
+    it 'get wrong argument' do
+      expect { Downloader.download_live_page 'SomethingUnique' }.to raise_error RuntimeError
+    end    
+  end
+
+  describe '#download_event_pages' do
+    let(:sport) { 'tennis' }
+    let(:addresses) { [ Betforker::MARATHON_BASE, Betforker::WILLIAMHILL_BASE ] }
+
+    before do
+      allow(Downloader).to receive(:download_from_marathon).
+	and_return open_event_page('marathon', 'first.html')
+      allow(Downloader).to receive(:download_from_williamhill).
+	and_return open_event_page('williamhill', 'first.html')
+    end
+
+    it 'marathon properly' do
+      result = Downloader.download_event_pages addresses
+      page = Nokogiri::HTML(result['marathon'])
+      script_with_data = page.css('script').find {|s| s.text.include? 'initData'}.text
+
+      expect(page.text.size).to be > 1024
+      expect(page.title).to include 'betting odds'
+      expect(page.css('.live-today-member-name').size).to eq 2
+      expect(page.css('.active-shortcut-menu-link').text).to include 'All Markets'
+      expect(script_with_data).to include '"oddsType":"Decimal"'
+      expect(script_with_data).to include '"locale_name":"en"'
+    end
+
+    it 'williamhill properly' do
+      result = Downloader.download_event_pages addresses
+      page = Nokogiri::HTML(result['williamhill'])
+
+      expect(page.css('#selectedLive').text).to include 'All Markets'
+      expect(page.css('#primaryCollectionContainer').text).to include 'Match Betting Live'
+    end
+
+    it 'block from provider' do
+      allow(Downloader).to receive(:download_from_marathon).
+	and_return page_from_provider
+      expect { Downloader.download_event_pages addresses }.to raise_error OpenSSL::SSL::SSLError
+    end
+  end
+end

data/spec/event_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.describe Betforker::Event do
+  let(:sport) { 'tennis' }
+  let(:addresses) do
+    [ 'http://first-valid-address.com',
+      'https://second-valid-address.com/en/bet',
+      'http://third-valid-address.com/where-is-it?q=42424',
+      'https://fourth-valid-address.com' ]
+  end
+  let(:event) { Event.new(addresses, sport) }
+  let(:webpages) do
+    { 'first' => fake_event_webpage,
+      'second' => fake_event_webpage,
+      'third' => fake_event_webpage,
+      'fourth' => fake_event_webpage }
+  end
+
+  describe '#get_webpages' do
+    it 'properly' do
+      allow(Downloader).to receive(:download_event_pages).
+	and_return(webpages)
+      event.get_webpages
+      pages = event.webpages
+
+      expect(pages.size).to eq 4
+      pages.each do |bookie_name, page|
+	expect(page.size).to be > 1024
+      end
+    end
+
+    it 'when returns only one page' do
+      allow(Downloader).to receive(:download_event_pages).
+	and_return({ 'marathon' => 'something interesting' })
+      event.get_webpages
+      pages = event.webpages
+
+      expect(pages.size).to eq 1
+    end
+
+    it 'when returns no pages' do
+      allow(Downloader).to receive(:download_event_pages).
+	and_return({})
+      event.get_webpages
+      pages = event.webpages
+
+      expect(pages.size).to eq 0
+    end
+
+  end
+
+  describe '#parse_webpages' do
+    let(:bookmakers) { [ 'Marathon'] }
+
+    it 'successfully' do
+      allow(Marathon).to receive(:parse_event).
+	and_return(updated_event(event))
+
+      event.webpages.merge! webpages
+      event.parse_webpages(bookmakers)
+      result = event.parsed_webpages
+
+      expect(result.size).to eq 1
+      expect(result.first.class).to eq Betforker::ParsedPage
+    end
+  end
+
+
+  describe '#forking' do
+    before do
+      3.times { event.parsed_webpages << ParsedPage.new }
+    end
+
+    it 'find forks' do
+      allow(Comparer).to receive(:compare).
+	and_return([Fork.new, Fork.new])
+      event.forking
+
+      expect(event.forks.size).to eq 3
+      expect(event.forks.flatten.size).to eq 6
+      event.forks.each do |f|
+	expect(f.class).to eq Array
+      end
+    end
+
+    it 'find no forks' do
+      allow(Comparer).to receive(:compare).
+	and_return([])
+      event.forking
+      expect(event.forks.size).to eq 3
+      expect(event.forks.flatten.size).to eq 0
+    end
+  end
+end

data/spec/features/without_downloads_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+RSpec.describe 'Betforker finds forks without downloads' do
+  let(:sport) { 'tennis' }
+  let(:event) { Betforker::Event.new [1,2,3], sport }
+  before do
+    $config = { min_percent: 1.1, filtering: true , bookmakers: ['Marathon', 'WilliamHill'] }
+  end
+
+  describe 'beginning with parsed webpages' do
+    it 'with many forks' do
+      event.parsed_webpages << parsed_marathon
+      event.parsed_webpages << parsed_williamhill
+      event.forking
+      forks = event.forks.flatten
+      
+      expect(forks.size).to eq 4
+      expect(forks.first.what).to eq 'match'
+      forks.each do |f|
+	expect(f.what).to match /match|game|set/
+	expect(f.score).to eq '0:0 (3:2)'
+	expect(f.players).to eq 'AwayPlayer  VS  HomePlayer'
+      end
+    end
+
+    it 'without any fork' do
+      changed_parsed_williamhill = parsed_marathon
+      changed_parsed_williamhill.bookie = 'WilliamHill'
+      event.parsed_webpages << parsed_marathon 
+      event.parsed_webpages << changed_parsed_williamhill
+      event.forking
+      forks = event.forks.flatten
+
+      expect(forks.size).to eq 0
+    end
+
+    it 'no forks if all pages from one bookie' do
+      changed_parsed_marathon = parsed_williamhill
+      changed_parsed_marathon.bookie = 'Marathon'
+      event.parsed_webpages << parsed_marathon
+      event.parsed_webpages << changed_parsed_marathon
+      event.forking
+      forks = event.forks.flatten
+
+      expect(forks.size).to eq 0
+    end
+  end
+
+  describe 'beginning with parsing webpages' do
+    let(:mar_with_forks) do
+      { 'marathon' => open_event_page('marathon', 'with_forks.html') }
+    end
+    let(:wh_with_forks) do
+      { 'williamhill' => open_event_page('williamhill', 'with_forks.html') }
+    end
+    let(:wh_without_forks) do
+      { 'williamhill' => open_event_page('williamhill', 'without_forks.html') }
+    end
+
+    it 'successfully with 1 fork' do
+      event.webpages.merge! mar_with_forks
+      event.webpages.merge! wh_with_forks
+      event.parse_webpages ['Marathon', 'WilliamHill']
+      event.forking
+      forks = event.forks.flatten
+
+      expect(forks.size).to eq 1
+      expect(forks.first.what).to eq 'game7'
+    end
+
+    it 'successfully with 2 forks' do
+      $config = { min_percent: 1.1, filtering: false }
+      event.webpages.merge! mar_with_forks
+      event.webpages.merge! wh_with_forks
+      event.parse_webpages ['Marathon', 'WilliamHill']
+      event.forking
+      forks = event.forks.flatten
+
+      expect(forks.size).to eq 2
+      expect(forks.first.what).to eq 'match'
+      expect(forks.last.what).to eq 'game7'
+      $config = { min_percent: 1.1, filtering: true }
+    end
+
+    it 'without forks' do
+      event.webpages.merge! mar_with_forks
+      event.webpages.merge! wh_without_forks
+      event.parse_webpages ['Marathon', 'WilliamHill']
+      event.forking
+      forks = event.forks.flatten
+
+      expect(forks.size).to eq 0
+    end
+  end
+
+  describe 'beginning with created Events' do
+    let(:event) { Event.new ['mar_with_forks', 'wh_with_forks'], sport }
+    let(:return_from_downloader) do
+      { 'marathon' => open_event_page('marathon', 'with_forks.html'),
+	'williamhill' => open_event_page('williamhill', 'with_forks.html') }
+    end
+    
+    it 'find a fork' do
+      allow(Downloader).to receive(:download_event_pages).
+	and_return(return_from_downloader)
+      allow(event).to receive(:all_bookmakers).
+	and_return(['Marathon', 'WilliamHill'])
+
+      forks = event.find_forks
+      f = forks.first
+
+      expect(forks.size).to eq 1
+      expect(f.what).to eq 'game7'
+      expect(f.bookmakers).to eq 'Marathon - WilliamHill'
+    end
+  end
+
+  describe 'from the beginning' do
+    it 'one time' do
+      allow(Betforker).to receive(:pull_live_events).
+	and_return unstructured_events
+      allow(Downloader).to receive(:download_from_marathon).
+	and_return open_event_page('marathon', 'with_forks.html')
+      allow(Downloader).to receive(:download_from_williamhill).
+	and_return open_event_page('williamhill', 'with_forks.html')
+
+      events = Betforker.build_events ['Marathon', 'WilliamHill'], sport
+      expect(events.size).to eq structured_events.size
+
+      events.each do |ev|
+	forks = ev.find_forks
+	if ev.addresses.include?(Betforker::MARATHON_BASE) and ev.addresses.include?(Betforker::WILLIAMHILL_BASE)
+	  expect(forks).to_not be_empty
+	end
+      end
+    end
+  end
+end