betforker 1.0.1

data/lib/betforker/parsed_page.rb

@@ -0,0 +1,13 @@
+module Betforker
+  class ParsedPage
+    attr_accessor :bookie, :home_player, :away_player, :score
+
+    def initialize(bookie: '')
+      @bookie = bookie
+      @home_player = {}
+      @away_player = {}
+      @score = ''
+    end
+
+  end
+end

data/lib/betforker/version.rb

@@ -0,0 +1,3 @@
+module Betforker
+  VERSION = '1.0.1'
+end

data/spec/betforker_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe Betforker do
+  let(:unstructured) { unstructured_events }
+  let(:structured) { structured_events }
+  $config = {}
+
+  describe '#build_events' do
+    let(:bookmakers) { ['First', 'Second'] }
+    let(:sport) { 'tennis' }
+
+    it 'successfully' do
+      allow(Betforker).to receive(:pull_live_events).
+	and_return(unstructured)
+      result = Betforker.build_events bookmakers, sport
+
+      expect(result.size).to eq 3
+      result.each do |e|
+	expect(e.class).to eq Event
+	expect(e.addresses.size).to be > 1
+      end
+    end
+
+    it 'with empty hash of events' do
+      allow(Betforker).to receive(:pull_live_events).
+	and_return({})
+      result = Betforker.build_events bookmakers, sport
+      expect(result.size).to eq 0
+    end
+  end
+
+  describe '#structure_events' do
+    it 'returns right hash' do
+      result = Betforker.structure_events unstructured
+      expect(result).to eq structured
+    end
+  end
+end
+

data/spec/bookmakers/__to_change__/betfair_test.rb

@@ -0,0 +1,40 @@
+require_relative 'test_helper'
+
+class BetfairTest < Minitest::Test
+
+  def setup
+    @bf = Betfair.new
+    @html_folder = 'test/html/betfair/'
+  end
+
+  def test_betfair_live_page_parsing
+    html = open("#{@html_folder}bf_live.htm").read
+    result = @bf.live_page_parsed(html)
+    assert_equal Hash, result.class
+    assert_equal 6, result.size
+    result.each do |addr, who|
+      assert addr.include?('www.betfair.com')
+      assert_equal String, addr.class
+      assert_equal String, who.class
+    end
+#    result.each {|k,r| puts k; puts r}
+  end
+
+  def test_betfair_event_parsing
+    events = []
+    (1..4).each do |num|
+      events << "#{@html_folder}betfair#{num}.html"
+    end
+    events.each do |event_page|
+      @bf = Betfair.new
+      res = @bf.event_parsed(open(event_page).read)
+#      p res
+      assert_equal(String, res[:home_player][:name].class)
+      assert_equal(String, res[:away_player][:name].class)
+      assert_equal(Hash, res[:home_player].class)
+      assert_equal(Hash, res[:away_player].class)
+      assert_equal(String, res[:score].class)
+      assert_equal('Betfair', res[:bookie])
+    end
+  end
+end

data/spec/bookmakers/__to_change__/parimatch_test.rb

@@ -0,0 +1,41 @@
+require_relative 'test_helper'
+
+class ParimatchTest < Minitest::Test
+
+  def setup
+    @pm = Parimatch.new
+    @html_folder = 'test/html/parimatch/'
+  end
+
+  def test_parimatch_live_page_parsing
+    html = open("#{@html_folder}pm_live.html").read
+    result = @pm.live_page_parsed(html)
+    assert_equal Hash, result.class
+    assert_equal 16, result.size
+    result.each do |addr, who|
+      assert addr.include?('parimatch.com')
+      assert_equal String, addr.class
+      assert_equal String, who.class
+    end
+#   result.each {|k,r| puts k; puts r}
+  end
+
+  def test_parimatch_event_parsing
+    events = []
+    (1..4).each do |num|
+      events << "#{@html_folder}parimatch#{num}.html"
+    end
+    events.each do |event_page|
+      @pm = Parimatch.new
+      res = @pm.event_parsed(open(event_page).read)
+#     p res
+      assert_equal(String, res[:home_player][:name].class)
+      assert_equal(String, res[:away_player][:name].class)
+      assert_equal(Hash, res[:home_player].class)
+      assert_equal(Hash, res[:away_player].class)
+      assert_equal(String, res[:score].class)
+      assert_equal('Parimatch', res[:bookie])
+    end
+  end
+
+end

data/spec/bookmakers/__to_change__/sbobet_test.rb

@@ -0,0 +1,40 @@
+require_relative 'test_helper'
+
+class SbobetTest < Minitest::Test
+
+  def setup
+    @sb = Sbobet.new
+    @html_folder = 'test/html/sbobet/'
+  end
+
+  def test_sbobet_live_page_parsing
+    html = open("#{@html_folder}sbobet_live.htm").read
+    result = @sb.live_page_parsed(html)
+    assert_equal Hash, result.class
+    assert_equal 8, result.size
+    result.each do |addr, who|
+      assert addr.include?('sbobet')
+      assert_equal String, addr.class
+      assert_equal String, who.class
+    end
+#    result.each {|k,r| puts k; puts r}
+  end
+
+  def test_sbobet_event_parsing
+    events = []
+    (1..4).each do |num|
+      events << "#{@html_folder}sb#{num}.htm"
+    end
+    events.each do |event_page|
+      @sb = Sbobet.new
+      res = @sb.event_parsed(open(event_page).read)
+#     p res
+      assert_equal(String, res[:home_player][:name].class)
+      assert_equal(String, res[:away_player][:name].class)
+      assert_equal(Hash, res[:home_player].class)
+      assert_equal(Hash, res[:away_player].class)
+      assert_equal(String, res[:score].class)
+      assert_equal('Sbobet', res[:bookie])
+    end
+  end
+end

data/spec/bookmakers/__to_change__/winlinebet_test.rb

@@ -0,0 +1,39 @@
+require_relative 'test_helper'
+
+class WinlinebetTest < Minitest::Test
+
+  def setup
+    @win = Winlinebet.new
+    @html_folder = 'test/html/winlinebet/'
+  end
+
+  def test_winline_live_page_parsing
+    html = open("#{@html_folder}win_live.htm").read
+    result = @win.live_page_parsed(html)
+    assert_equal Hash, result.class
+    result.each do |addr, who|
+      assert addr.include?('winlinebet')
+      assert_equal String, addr.class
+      assert_equal String, who.class
+    end
+#    result.each {|k,r| puts k; puts r}
+  end
+
+  def test_winline_event_parsing
+    events = []
+    (1..4).each do |num|
+      events << "#{@html_folder}win#{num}.htm"
+    end
+    events.each do |event_page|
+      @win = Winlinebet.new
+      res = @win.event_parsed(open(event_page).read)
+#     p res
+      assert_equal(String, res[:home_player][:name].class)
+      assert_equal(String, res[:away_player][:name].class)
+      assert_equal(Hash, res[:home_player].class)
+      assert_equal(Hash, res[:away_player].class)
+      assert_equal(String, res[:score].class)
+      assert_equal('Winlinebet', res[:bookie])
+    end
+  end
+end

data/spec/bookmakers/marathon_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe Betforker::Bookmakers::Marathon do
+  describe '#parse_live_page' do
+    let(:sport) { 'tennis' }
+    let(:result) { Marathon.parse_live_page(webpage, sport) }
+
+    context 'tennis successfully' do
+      let(:webpage) { open_right_live_page 'marathon' }
+
+      specify { expect(result.instance_of?(Hash)).to be true }
+      specify { expect(result.size).not_to eq 0 }
+
+      it "every hash key contains address" do
+	result.keys.each do |key|
+	  expect(key).to include Betforker::MARATHON_BASE
+	end
+      end
+    end
+
+    context 'tennis with no events' do
+      let(:webpage) { marathon_live_page_without_events }
+      specify { expect(result.size).to eq 0 }
+    end
+
+    context 'tennis with wrong webpage' do
+      let(:webpage) { open_right_live_page 'williamhill' }
+      specify { expect(result.size).to eq 0 }
+    end
+  end
+
+  describe '#parse_event' do
+    let(:sport) { 'tennis' }
+    let(:result) do 
+      event = Event.new [1,2,3], sport
+      event.webpages.merge!({ 'marathon' => webpage })
+      Marathon.parse_event(event, sport)
+      event.parsed_webpages.first
+    end
+
+    context 'tennis C.Cianci/P.Martins vs B.Luz/J.Vale Costa' do
+      let(:webpage) { open_event_page('marathon', 'first.html') }
+      it 'all must be good' do
+	expect(result.home_player[:name]).to eq 'CianciMartins'
+	expect(result.away_player[:name]).to eq 'CostaLuz'
+	expect(result.home_player[:match]).to eq 3.05
+	expect(result.away_player[:match]).to eq 1.37
+	expect(result.score).to eq '30:0 (1:0)'
+	expect(result.home_player[:set]['1']).to eq 2.14
+	expect(result.away_player[:set]['1']).to eq 1.70
+	expect(result.home_player[:game]['3']).to eq 3.00
+	expect(result.away_player[:game]['3']).to eq 1.38
+      end
+    end
+
+    context 'tennis Melzer vs Skugor' do
+      let(:webpage) { open_event_page('marathon', 'second.html') }
+      it 'all must be good' do
+	expect(result.home_player[:name]).to eq 'Melzer'
+	expect(result.away_player[:name]).to eq 'Skugor'
+	expect(result.home_player[:match]).to eq 1.89
+	expect(result.away_player[:match]).to eq 1.909
+	expect(result.home_player[:set]['2']).to eq 7.20
+	expect(result.away_player[:set]['2']).to eq 1.095
+	expect(result.home_player[:game]['7']).to eq 4.40
+	expect(result.away_player[:game]['7']).to eq 1.21
+      end
+    end
+  end
+
+  describe '#concatenated_names' do
+    let(:result) { Marathon.concatenated_names(names) }
+
+    context 'First, Player v Second, Player' do
+      let(:names) { 'First, Player v Second, Player' }
+      specify { expect(result).to eq 'FirstSecond' }
+    end
+
+    context 'R.Klaasen / R.Ram v O.Marach / F.Martin' do
+      let(:names) { 'R.Klaasen / R.Ram v O.Marach / F.Martin' }
+      specify { expect(result).to eq 'KlaasenMarachMartinRam' }
+    end
+  end
+end

data/spec/bookmakers/williamhill_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe Betforker::Bookmakers::WilliamHill do
+  describe '#parse_live_page' do
+    let(:sport) { 'tennis' }
+    let(:result) { WilliamHill.parse_live_page(webpage, sport) }
+
+    context 'tennis successfully' do
+      let(:webpage) { open_right_live_page 'williamhill' }
+
+      specify { expect(result.instance_of?(Hash)).to be true }
+      specify { expect(result.size).not_to eq 0 }
+
+      it "every hash key contains address" do
+	result.keys.each do |key|
+	  expect(key).to include Betforker::WILLIAMHILL_BASE
+	end
+      end
+    end
+
+    context 'tennis with no events' do
+      let(:webpage) { williamhill_live_page_without_events }
+      specify { expect(result.size).to eq 0 }
+    end
+
+    context 'tennis with wrong webpage' do
+      let(:webpage) { open_right_live_page 'marathon' }
+      specify { expect(result.size).to eq 0 }
+    end
+  end
+
+  describe '#parse_event' do
+    let(:sport) { 'tennis' }
+    let(:result) do 
+      event = Event.new [1,2,3], sport
+      event.webpages.merge!({ 'williamhill' => webpage })
+      WilliamHill.parse_event(event, sport)
+      event.parsed_webpages.first
+    end
+
+    context 'tennis Motti/Peng vs Donati/Sonego' do
+      let(:webpage) { open_event_page('williamhill', 'first.html') }
+      it 'all must be good' do
+	expect(result.home_player[:name]).to eq 'MottiPeng'
+	expect(result.away_player[:name]).to eq 'DonatiSonego'
+	expect(result.home_player[:match]).to eq 3.75
+	expect(result.away_player[:match]).to eq 1.25
+	expect(result.home_player[:game]['4']).to eq 4.00
+	expect(result.away_player[:game]['4']).to eq 1.22
+      end
+    end
+
+    context 'tennis Schmiedlova vs Argyelan' do
+      let(:webpage) { open_event_page('williamhill', 'second.html') }
+      it 'all must be good' do
+	expect(result.home_player[:name]).to eq 'Schmiedlova'
+	expect(result.away_player[:name]).to eq 'Argyelan'
+	expect(result.home_player[:match]).to eq 1.73
+	expect(result.away_player[:match]).to eq 2.00
+	expect(result.home_player[:game]['1']).to eq 2.00
+	expect(result.away_player[:game]['1']).to eq 1.73
+	expect(result.home_player[:game]['2']).to eq 1.40
+	expect(result.away_player[:game]['2']).to eq 2.75
+      end
+    end
+  end
+
+  describe '#concatenated_names' do
+    let(:result) { WilliamHill.concatenated_names(names) }
+
+    context 'Luna Meers v Steffii Distelmans' do
+      let(:names) { 'Luna Meers v Steffii Distelmans' }
+      specify { expect(result).to eq 'DistelmansMeers' }
+    end
+
+    context 'Oleksandr Bielinsky/Michail Fufygin v Vitaly Kozyukov/Aleksander Ovcharov' do
+      let(:names) { 'Oleksandr Bielinsky/Aleksander Ovcharov v Vitaly Kozyukov/Michail Fufygin' }
+      specify { expect(result).to eq 'BielinskyFufyginKozyukovOvcharov' }
+    end
+  end
+end

data/spec/comparer_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+RSpec.describe Betforker::Comparer do
+  before do
+    $config = { min_percent: 1.1, filtering: true }
+  end
+
+  describe '#compare' do
+    let(:first) do
+      parsed = ParsedPage.new bookie: 'WilliamHill'
+      parsed.score = ''
+      parsed.home_player = 
+	{ name: 'Home_Player', match: 1.6, game: {'5' => 2.2 }, set: {'1' => 1.4 } }
+      parsed.away_player =
+	{ name: 'Away_Player', match: 2.3, game: {'5' => 1.7 }, set: {'1' => 2.9 } } 
+      parsed
+    end
+
+    let(:second) do
+      parsed = ParsedPage.new bookie: 'Betfair'
+      parsed.score = '0:0 (2:1)'
+      parsed.home_player =
+	{ name: 'Home_Player', match: 1.3, game: {'5' => 2.9 }, set: {'1' => 1.6 } }
+      parsed.away_player =
+	{ name: 'Away_Player', match: 3.3, game: {'5' => 1.4 }, set: {'1' => 2.2 } } 
+      parsed
+    end
+
+    it 'find forks' do
+      forks = Comparer.compare first, second
+      expect(forks).not_to be_empty
+      forks.each do |f|
+	expect(f.class).to eq Fork
+	expect(f.bookmakers).to eq 'WilliamHill - Betfair'
+	expect(f.players).to eq 'Away_Player  VS  Home_Player'
+	expect(f.score).to eq '0:0 (2:1)'
+	expect(f.what).to match /match|game5|set1/
+      end
+    end
+
+    it 'find only one fork(game)' do
+      scores = ['15:0 (2:1)', '30:0 (0:3)', '0:0 (0:2)', '0:0 (1:1)']
+      scores.each do |s|
+	second.score = s
+	forks = Comparer.compare first, second
+	expect(forks).not_to be_empty
+	expect(forks.size).to eq 1
+	expect(forks[0].what).to eq 'game5'
+      end
+    end
+
+    it 'find if it is break' do
+      scores = ['0:0 (0:0)', '0:0 (2:3)', '0:0 (6:2)', '0:0 (5:7)']
+      scores.each do |s|
+	second.score = s
+	second.home_player[:game]['5'] = 2.2
+	forks = Comparer.compare first, second
+	expect(forks).not_to be_empty
+	expect(forks.size).to eq 2
+	forks.each do |f|
+	  expect(f.what).to match /match|set1/
+	end
+      end
+    end
+
+    it 'do not find forks' do
+      other_second = second.dup
+      other_second.home_player = second.away_player
+      forks = Comparer.compare first, other_second
+      expect(forks).to be_empty
+    end
+
+    it 'do not find when not break' do
+      scores = ['0:0 (2:2)', '15:30 (2:3)', '0:0 (6:6)']
+      scores.each do |s|
+	second.score = s
+	forks = Comparer.compare first, second
+	expect(forks).to be_empty
+      end
+    end
+  end
+
+  describe '#check_sorting' do
+    let(:homeplayer) { 'Aaaa' }
+    let(:awayplayer) { 'Zzzz' }
+    let(:first) do
+      parsed = ParsedPage.new bookie: 'First'
+      parsed.home_player[:name] = homeplayer
+      parsed.away_player[:name] = awayplayer
+      parsed
+    end
+    let(:second) do
+      parsed = ParsedPage.new bookie: 'Second'
+      parsed.home_player[:name] = homeplayer
+      parsed.away_player[:name] = awayplayer
+      parsed
+    end
+
+    it 'will not change anything' do
+      Comparer.check_sorting first, second
+      
+      expect(first.home_player[:name]).to eq homeplayer
+      expect(first.away_player[:name]).to eq awayplayer
+      expect(second.home_player[:name]).to eq homeplayer
+      expect(second.away_player[:name]).to eq awayplayer
+    end
+
+    it 'will change players' do
+      Comparer.change_names(first)
+      expect(first.home_player[:name]).to_not eq homeplayer
+      expect(first.away_player[:name]).to_not eq awayplayer
+      expect(second.home_player[:name]).to eq homeplayer
+      expect(second.away_player[:name]).to eq awayplayer
+      Comparer.check_sorting first, second
+      expect(first.home_player[:name]).to eq homeplayer
+      expect(first.away_player[:name]).to eq awayplayer
+      expect(second.home_player[:name]).to eq homeplayer
+      expect(second.away_player[:name]).to eq awayplayer
+    end
+  end
+
+  describe '#calculate' do
+    it 'when it is a fork' do
+      x, y = 1.5, 4.0
+      percent = Comparer.calculate x, y
+      expect(percent).to be > 2.0
+    end
+
+    it 'when it is a fork(reverted x and y)' do
+      x, y = 4.0, 1.5
+      percent = Comparer.calculate x, y
+      expect(percent).to be > 2.0
+    end
+
+    it 'when it is not a fork' do
+      x, y = 1.2, 4.0
+      percent = Comparer.calculate x, y
+      expect(percent).to be < 2.0
+    end
+
+    it 'when x or y are 0' do
+      x, y = 0.0, 0.0
+      percent = Comparer.calculate x, y
+      expect(percent).to be == -3.5
+    end
+  end
+
+  describe '#is_a_break?' do
+    it 'when a break' do
+      ['0:0 (2:3)', '0:0 (5:2)', '0:0 (0:0)'].each do |score|
+	state = Comparer.is_a_break? score
+	expect(state).to be_truthy
+      end
+    end
+    it 'when not a break' do
+      ['0:0 (4:4)', '0:0 (6:6)', '30:15 (0:1)'].each do |score|
+	state = Comparer.is_a_break? score
+	expect(state).to be_falsey
+      end
+    end 
+  end
+end