odeon_uk 4.0.1 → 5.1.0

data/test/lib/odeon_uk/cinema_test.rb

@@ -1,262 +1,113 @@
 require_relative '../../test_helper'
 
-describe OdeonUk::Cinema do
-  include ApiFixturesHelper
-
-  let(:described_class) { OdeonUk::Cinema }
-  let(:api_response) { FakeApiResponse.new }
-
-  before { WebMock.disable_net_connect! }
-  after { WebMock.allow_net_connect! }
-
-  describe '.new(id)' do
-    subject { described_class.new(id) }
-
-    describe 'Brighton' do
-      let(:id) { 71 }
-
-      it 'returns a cinema with a string id' do
-        subject.must_be_instance_of(described_class)
-        subject.id.must_equal(id.to_s)
-      end
-    end
+class OdeonUk::CinemaTest < Minitest::Test
+  def setup
+    @api_response = FakeApiResponse.new
   end
 
-  describe '.all' do
-    subject { described_class.all }
+  def test_new_returns_cinema_with_string_id
+    cinema = OdeonUk::Cinema.new(824)
 
-    it 'returns an array of cinemas' do
-      OdeonUk::Internal::ApiResponse.stub :new, api_response do
-        subject.must_be_instance_of(Array)
-        subject.each do |element|
-          element.must_be_instance_of(described_class)
-        end
-        subject.count.must_be :>, 100
-      end
-    end
+    assert_instance_of OdeonUk::Cinema, cinema
+    assert_equal '824', cinema.id
   end
 
-  describe '#adr' do
-    subject { described_class.new(id).adr }
-
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal(street_address:   'Kingswest',
-                             extended_address: nil,
-                             locality:         'Brighton',
-                             region:           nil,
-                             postal_code:      'BN1 2RE',
-                             country_name:     'United Kingdom')
-        end
-      end
-    end
+  def test_new_zero_pads_id
+    assert_equal '017', OdeonUk::Cinema.new(17).id
   end
 
-  describe '#address' do
-    subject { described_class.new(id).address }
-
-    describe 'London address' do
-      let(:id) { 105 }
+  def test_all_returns_cinemas
+    with_fake_api do
+      cinemas = OdeonUk::Cinema.all
 
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal(street_address:   '24-26 Leicester Square',
-                             extended_address: nil,
-                             locality:         'London',
-                             region:           nil,
-                             postal_code:      'WC2H 7JY',
-                             country_name:     'United Kingdom')
-        end
-      end
+      assert(cinemas.all? { |cinema| cinema.instance_of?(OdeonUk::Cinema) })
+      assert_equal %w(017 153 824 955), cinemas.map(&:id)
     end
   end
 
-  describe '#brand' do
-    subject { described_class.new(id).brand }
-    describe 'short address' do
-      let(:id) { 71 }
+  def test_adr_has_no_postcode
+    expected = {
+      street_address:   '3 Example Parade',
+      extended_address: 'Seafront',
+      locality:         'Brighton',
+      region:           nil,
+      postal_code:      nil,
+      country_name:     'United Kingdom'
+    }
 
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Odeon'
-        end
-      end
+    with_fake_api do
+      assert_equal expected, OdeonUk::Cinema.new(824).adr
     end
   end
 
-  describe '#country_name' do
-    subject { described_class.new(id).country_name }
-    describe 'short address' do
-      let(:id) { 71 }
+  def test_address_for_london
+    expected = {
+      street_address:   '2 Example Square',
+      extended_address: '',
+      locality:         'London',
+      region:           nil,
+      postal_code:      nil,
+      country_name:     'United Kingdom'
+    }
 
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'United Kingdom'
-        end
-      end
+    with_fake_api do
+      assert_equal expected, OdeonUk::Cinema.new(153).address
     end
   end
 
-  describe '#extended_address' do
-    subject { described_class.new(id).extended_address }
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal ''
-        end
-      end
-    end
+  def test_brand
+    assert_equal 'Odeon', OdeonUk::Cinema.new(824).brand
   end
 
-  describe '#full_name' do
-    subject { described_class.new(id).full_name }
-    describe 'Brighton' do
-      let(:id) { 71 }
-
-      it 'returns cinema name' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Odeon Brighton'
-        end
-      end
-    end
-
-    describe 'Leicester Square' do
-      let(:id) { 105 }
-
-      it 'returns cinema name' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Odeon Leicester Square'
-        end
-      end
+  def test_full_name
+    with_fake_api do
+      assert_equal 'Odeon Brighton', OdeonUk::Cinema.new(824).full_name
+      assert_equal 'Odeon Leicester Square', OdeonUk::Cinema.new(153).full_name
     end
   end
 
-  describe '#locality' do
-    subject { described_class.new(id).locality }
-    describe 'Short Address (Brighton)' do
-      let(:id) { 71 }
-
-      it 'returns town name' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Brighton'
-        end
-      end
+  def test_name_removes_london_prefix
+    with_fake_api do
+      assert_equal 'Leicester Square', OdeonUk::Cinema.new(153).name
     end
   end
 
-  describe '#name' do
-    subject { described_class.new(id).name }
-    describe 'Brighton' do
-      let(:id) { 71 }
-
-      it 'returns cinema name' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Brighton'
-        end
-      end
-    end
-
-    describe 'Leicester Square' do
-      let(:id) { 105 }
-
-      it 'returns cinema name' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Leicester Square'
-        end
-      end
+  def test_postal_code_is_empty
+    with_fake_api do
+      assert_equal '', OdeonUk::Cinema.new(824).postal_code
     end
   end
 
-  describe '#postal_code' do
-    subject { described_class.new(id).postal_code }
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'BN1 2RE'
-        end
-      end
-    end
-
-    describe 'short address (London)' do
-      let(:id) { 211 }
-
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'SE1 8XR'
-        end
-      end
-    end
-
-    describe 'short address (extra London Postcode)' do
-      let(:id) { 105 }
-
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'WC2H 7JY'
-        end
-      end
+  def test_slug
+    with_fake_api do
+      assert_equal 'odeon-brighton', OdeonUk::Cinema.new(824).slug
     end
   end
 
-  describe '#region' do
-    subject { described_class.new(id).region }
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns the postcode' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal ''
-        end
-      end
+  def test_url
+    with_fake_api do
+      assert_equal 'https://www.odeon.co.uk/cinemas/brighton/',
+                   OdeonUk::Cinema.new(824).url
     end
   end
 
-  describe '#slug' do
-    subject { described_class.new(id).slug }
-
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns first line of address' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'odeon-brighton'
-        end
-      end
+  def test_url_keeps_london_prefix
+    with_fake_api do
+      assert_equal 'https://www.odeon.co.uk/cinemas/london-leicester-square/',
+                   OdeonUk::Cinema.new(153).url
     end
   end
 
-  describe '#street_address' do
-    subject { described_class.new(id).street_address }
-
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns first line of address' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'Kingswest'
-        end
-      end
+  def test_url_uses_slug_that_differs_from_name
+    with_fake_api do
+      assert_equal 'https://www.odeon.co.uk/cinemas/manchester-trafford-centre/',
+                   OdeonUk::Cinema.new(955).url
     end
   end
 
-  describe '#url' do
-    subject { described_class.new(id).url }
+  private
 
-    describe 'short address' do
-      let(:id) { 71 }
-
-      it 'returns first line of address' do
-        OdeonUk::Internal::ApiResponse.stub :new, api_response do
-          subject.must_equal 'http://www.odeon.co.uk/cinemas/brighton/71/'
-        end
-      end
-    end
+  def with_fake_api(&block)
+    OdeonUk::Internal::ApiResponse.stub(:new, @api_response, &block)
   end
 end

data/test/lib/odeon_uk/internal/api_response_test.rb

@@ -1,47 +1,66 @@
 require_relative '../../../test_helper'
 
-describe OdeonUk::Internal::ApiResponse do
+class OdeonUk::Internal::ApiResponseTest < Minitest::Test
   include ApiFixturesHelper
 
-  let(:described_class) { OdeonUk::Internal::ApiResponse }
+  BASE_URL = 'https://vwc.odeon.co.uk/WSVistaWebClient/ocapi/v1'.freeze
+  HEADERS = {
+    'Authorization' => 'Bearer guest-jwt', 'Connect-Region-Code' => 'UK'
+  }.freeze
 
-  before { WebMock.disable_net_connect! }
-  after { WebMock.allow_net_connect! }
+  def setup
+    OdeonUk.token = 'guest-jwt'
+  end
+
+  def teardown
+    OdeonUk.token = nil
+    super
+  end
+
+  def test_sites
+    stub_request(:get, "#{BASE_URL}/sites")
+      .with(headers: HEADERS)
+      .to_return(status: 200, body: sites_json)
+
+    sites = api.sites
+
+    assert_kind_of Array, sites
+    assert_includes sites.first.keys, 'id'
+  end
 
-  describe '#app_init' do
-    subject { described_class.new.app_init }
+  def test_showtimes
+    stub_request(:get, "#{BASE_URL}/showtimes/by-business-date/2026-10-24")
+      .with(query: { 'siteIds' => '824' }, headers: HEADERS)
+      .to_return(status: 200, body: showtimes_json('824'))
 
-    before { stub_post('app-init', nil, app_init_plist) }
+    showtimes = api.showtimes('824', Date.new(2026, 10, 24))
 
-    it 'returns a hash' do
-      subject.class.must_equal Hash
-      subject.keys.must_equal(%w(films offers))
-    end
+    assert_equal %w(businessDate relatedData showtimes), showtimes.keys.sort
   end
 
-  describe '#all_cinemas' do
-    subject { described_class.new.all_cinemas }
+  def test_missing_token_raises_before_request
+    OdeonUk.token = nil
+
+    assert_raises(OdeonUk::AuthenticationError) { api.sites }
+  end
 
-    before { stub_post('all-cinemas', nil, all_cinemas_plist) }
+  def test_rejected_token_raises
+    stub_request(:get, "#{BASE_URL}/sites").to_return(status: 401)
 
-    it 'returns a hash' do
-      subject.class.must_equal Hash
-      subject.keys.must_equal(%w(sites))
-    end
+    assert_raises(OdeonUk::AuthenticationError) { api.sites }
   end
 
-  describe '#showtimes(id)' do
-    subject { described_class.new.film_times(71, 15_130) }
+  def test_server_error_omits_body
+    stub_request(:get, "#{BASE_URL}/sites").to_return(status: 500, body: 'secret')
+
+    error = assert_raises(RuntimeError) { api.sites }
+
+    assert_equal 'Vista HTTP error 500', error.message
+  end
 
-    before do
-      stub_post('film-times',
-                { s: '71', m: '15130' },
-                film_times_plist_random)
-    end
+  private
 
-    it 'returns an array' do
-      subject.class.must_equal Array
-      subject.each { |group| group.keys.must_equal(%w(date attributes)) }
-    end
+  def api
+    OdeonUk::Internal::ApiResponse.new
   end
 end

data/test/lib/odeon_uk/internal/fixture_shape_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../../test_helper'
+
+class FixtureShapeTest < Minitest::Test
+  include ApiFixturesHelper
+  include ApiShapes
+
+  def test_sites_fixture_matches_shape
+    assert_sites_shape(JSON.parse(sites_json))
+  end
+
+  def test_showtimes_fixture_matches_shape
+    assert_showtimes_shape(JSON.parse(showtimes_json('824')))
+  end
+end

data/test/lib/odeon_uk/internal/guest_token_test.rb

@@ -0,0 +1,84 @@
+require_relative '../../../test_helper'
+require 'base64'
+require 'tmpdir'
+
+class OdeonUk::Internal::GuestTokenTest < Minitest::Test
+  def setup
+    @directory = Dir.mktmpdir('odeon-guest-token')
+  end
+
+  def teardown
+    FileUtils.remove_entry(@directory)
+    OdeonUk.token = nil
+  end
+
+  def test_fetch_returns_token_from_page_data
+    token = token_expiring_at(Time.now + 3600)
+    curl = fake_curl("#{page_with(token)}\n200")
+
+    assert_equal token, guest_token(curl).fetch
+  end
+
+  def test_fetch_rejects_expired_token
+    curl = fake_curl("#{page_with(token_expiring_at(Time.now - 60))}\n200")
+
+    assert_raises(OdeonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_rejects_page_without_page_data
+    curl = fake_curl("<html></html>\n200")
+
+    assert_raises(OdeonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_rejects_redirect_to_queue
+    curl = fake_curl("\n302")
+
+    assert_raises(OdeonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_rejects_failed_command
+    curl = fake_curl('', exit_status: 7)
+
+    assert_raises(OdeonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_explains_missing_executable
+    error = assert_raises(OdeonUk::AuthenticationError) do
+      guest_token(File.join(@directory, 'missing')).fetch
+    end
+
+    assert_match(/curl-impersonate/, error.message)
+  end
+
+  def test_acquire_token_sets_token
+    token = token_expiring_at(Time.now + 3600)
+
+    OdeonUk.acquire_token!(curl: fake_curl("#{page_with(token)}\n200"))
+
+    assert_equal token, OdeonUk.token
+  end
+
+  private
+
+  def guest_token(curl)
+    OdeonUk::Internal::GuestToken.new(curl: curl)
+  end
+
+  def token_expiring_at(time)
+    payload = Base64.urlsafe_encode64(JSON.generate('exp' => time.to_i), padding: false)
+    "header.#{payload}.signature"
+  end
+
+  def page_with(token)
+    data = { 'api' => { 'apiUrl' => 'https://vwc.odeon.co.uk/WSVistaWebClient', 'authToken' => token } }
+    "<script>\n  window.initialData = #{JSON.generate(data)};\n  window.pageData = [];\n</script>"
+  end
+
+  def fake_curl(output, exit_status: 0)
+    path = File.join(@directory, 'curl-impersonate')
+    File.write(path, "#!#{RbConfig.ruby}\nSTDOUT.write(#{output.dump})\nexit #{exit_status}\n")
+    File.chmod(0o755, path)
+    path
+  end
+end

data/test/lib/odeon_uk/internal/parser/api/showtime_test.rb

@@ -0,0 +1,77 @@
+require_relative '../../../../../test_helper'
+
+class OdeonUk::Internal::Parser::Api::ShowtimeTest < Minitest::Test
+  FILMS = {
+    'HO1' => { 'title' => { 'text' => 'Jailer 2 (Tamil)' } },
+    'HO2' => { 'title' => { 'text' => 'Cine-Excess 2026: Scum Of The Earth' } },
+    'HO3' => { 'title' => { 'text' => 'From Dusk Till Dawn (1996)' } }
+  }.freeze
+
+  ATTRIBUTES = {
+    '1' => { 'shortName' => { 'text' => 'TamilA' }, 'name' => { 'text' => 'Tamil (Audio)' } },
+    '2' => { 'shortName' => { 'text' => 'EnglishSub' }, 'name' => { 'text' => 'English (Sub)' } },
+    '3' => { 'shortName' => { 'text' => 'IMAX' }, 'name' => { 'text' => 'IMAX' } },
+    '4' => { 'shortName' => { 'text' => 'OpenCapt' }, 'name' => { 'text' => 'Open Captioned' } },
+    '5' => { 'shortName' => { 'text' => 'Wheelchair' }, 'name' => { 'text' => 'Wheelchair Accessible' } }
+  }.freeze
+
+  def test_to_hash
+    expected = {
+      booking_url: 'https://www.odeon.co.uk/ticketing/seat-picker/?showtimeId=824-1',
+      dimension: '2d',
+      festival: nil,
+      film_name: 'Jailer 2',
+      film_year: nil,
+      language: nil,
+      starting_at: Time.utc(2026, 10, 24, 17, 30),
+      variant: []
+    }
+
+    assert_equal expected, parse
+  end
+
+  def test_3d_glasses
+    assert_equal '3d', parse(requires3d: true)[:dimension]
+  end
+
+  def test_audio_language
+    assert_equal 'Tamil', parse(attribute_ids: %w(1 2 3 5))[:language]
+  end
+
+  def test_maps_known_attributes_to_variants
+    assert_equal %w(subtitled imax), parse(attribute_ids: %w(1 2 3 5))[:variant]
+  end
+
+  def test_festival_moves_from_title_to_attribute
+    showtime = parse(film_id: 'HO2')
+
+    assert_equal Cinebase::Festival.new(name: 'Cine-Excess', year: 2026), showtime[:festival]
+    assert_equal 'Scum Of The Earth', showtime[:film_name]
+  end
+
+  def test_film_year_moves_from_title_to_attribute
+    showtime = parse(film_id: 'HO3')
+
+    assert_equal 1996, showtime[:film_year]
+    assert_equal 'From Dusk Till Dawn', showtime[:film_name]
+  end
+
+  def test_open_captions_and_subtitles_are_one_variant
+    assert_equal %w(subtitled), parse(attribute_ids: %w(2 4))[:variant]
+  end
+
+  private
+
+  def parse(attribute_ids: [], requires3d: false, film_id: 'HO1')
+    data = {
+      'id' => '824-1',
+      'filmId' => film_id,
+      'schedule' => { 'startsAt' => '2026-10-24T18:30:00+01:00' },
+      'attributeIds' => attribute_ids,
+      'requires3dGlasses' => requires3d
+    }
+    OdeonUk::Internal::Parser::Api::Showtime.new(
+      data, films: FILMS, attributes: ATTRIBUTES
+    ).to_hash
+  end
+end