cineworld_uk 4.1.0 → 4.3.0

data/test/lib/cineworld_uk/internal/parser/api/cinema_address_test.rb

@@ -1,94 +1,53 @@
 require_relative '../../../../../test_helper'
-require_relative '../../../../../support/fixture_reader'
 
-describe CineworldUk::Internal::Parser::Api::CinemaAddress do
-  include Support::FixtureReader
-
-  let(:described_class) { CineworldUk::Internal::Parser::Api::CinemaAddress }
-  let(:api_response) { Minitest::Mock.new }
-
-  before { WebMock.disable_net_connect! }
-  after { WebMock.allow_net_connect! }
-
-  describe '#to_hash' do
-    subject { described_class.new(id).to_hash }
-
-    before do
-      api_response.expect(:cinema_list, cinema_list_json)
-    end
-
-    describe 'passed simple (Brighton)' do
-      let(:id) { 14 }
-
-      it 'returns address hash' do
-        CineworldUk::Internal::ApiResponse.stub :new, api_response do
-          _(subject).must_equal(street_address:   'Brighton Marina Village',
-                             extended_address: nil,
-                             locality:         'Brighton',
-                             region:           nil,
-                             postal_code:      'BN2 5UF',
-                             country:          'United Kingdom')
-        end
-      end
-    end
-
-    describe 'passed three line (NEC)' do
-      let(:id) { 90 }
-
-      it 'returns address hash' do
-        CineworldUk::Internal::ApiResponse.stub :new, api_response do
-          _(subject).must_equal(street_address:   'Resorts World',
-                             extended_address: 'Pendigo Way',
-                             locality:         'Birmingham',
-                             region:           nil,
-                             postal_code:      'B40 1PU',
-                             country:          'United Kingdom')
-        end
-      end
-    end
+class CineworldUk::Internal::Parser::Api::CinemaAddressTest < Minitest::Test
+  CINEMAS = [
+    {
+      'id' => '014', 'displayName' => 'Brighton',
+      'addressInfo' => { 'address1' => '1 Example Marina', 'city' => 'Brighton',
+                         'postalCode' => 'BN2 0ZZ' }
+    },
+    {
+      'id' => '090', 'displayName' => 'Birmingham Example',
+      'addressInfo' => { 'address1' => '2 Example Resort', 'address2' => 'Example Way',
+                         'city' => 'Birmingham', 'postalCode' => 'B40 0ZZ' }
+    },
+    {
+      'id' => '037', 'displayName' => 'Edinburgh Example',
+      'addressInfo' => { 'address1' => '3 Example Park', 'address3' => '4 Example Street',
+                         'city' => 'Edinburgh', 'postalCode' => 'EH11 0ZZ' }
+    },
+    {
+      'id' => '103', 'displayName' => 'London - Leicester Square',
+      'addressInfo' => { 'address1' => '5 Example Square', 'address2' => 'Example Row',
+                         'city' => 'London', 'postalCode' => 'WC2H 0ZZ' }
+    }
+  ].freeze
+
+  def test_one_line_address
+    assert_address 14, street_address: '1 Example Marina', extended_address: nil,
+                       locality: 'Brighton', region: nil, postal_code: 'BN2 0ZZ'
+  end
 
-    describe 'passed three line (Edinburgh)' do
-      let(:id) { 37 }
+  def test_second_line_is_extended_address
+    assert_address 90, street_address: '2 Example Resort', extended_address: 'Example Way',
+                       locality: 'Birmingham', region: nil, postal_code: 'B40 0ZZ'
+  end
 
-      it 'returns address hash' do
-        CineworldUk::Internal::ApiResponse.stub :new, api_response do
-          _(subject).must_equal(street_address:   'Fountain Park',
-                             extended_address: '130/3 Dundee Street',
-                             locality:         'Edinburgh',
-                             region:           nil,
-                             postal_code:      'EH11 1AF',
-                             country:          'United Kingdom')
-        end
-      end
-    end
+  def test_third_line_is_extended_address_without_second
+    assert_address 37, street_address: '3 Example Park', extended_address: '4 Example Street',
+                       locality: 'Edinburgh', region: nil, postal_code: 'EH11 0ZZ'
+  end
 
-    describe 'passed two line (Leicester Square)' do
-      let(:id) { 103 }
+  def test_london_has_region_and_no_extended_address
+    assert_address 103, street_address: '5 Example Square', extended_address: nil,
+                        locality: 'London', region: 'London', postal_code: 'WC2H 0ZZ'
+  end
 
-      it 'returns address hash' do
-        CineworldUk::Internal::ApiResponse.stub :new, api_response do
-          _(subject).must_equal(street_address:   '5-6 Leicester Square',
-                             extended_address: nil,
-                             locality:         'London',
-                             region:           'London',
-                             postal_code:      'WC2H 7NA',
-                             country:          'United Kingdom')
-        end
-      end
-    end
+  private
 
-    # describe 'passed non-existant api' do
-    #   let(:id) { 0 }
-    #
-    #   it 'returns hash of nils' do
-    #     _(subject).must_be_instance_of(Hash)
-    #     _(subject).must_equal(street_address:   nil,
-    #                        extended_address: nil,
-    #                        locality:         "not an address",
-    #                        region:           nil,
-    #                        postal_code:      "not an address",
-    #                        country:          "United Kingdom")
-    #   end
-    # end
+  def assert_address(id, expected)
+    assert_equal expected.merge(country: 'United Kingdom'),
+                 CineworldUk::Internal::Parser::Api::CinemaAddress.new(id, CINEMAS).to_hash
   end
 end

data/test/lib/cineworld_uk/internal/parser/api/film_test.rb

@@ -1,160 +1,98 @@
 require_relative '../../../../../test_helper'
-require_relative '../../../../../support/fixture_reader'
 
-describe CineworldUk::Internal::Parser::Api::Film do
-  include Support::FixtureReader
-
-  let(:described_class) { CineworldUk::Internal::Parser::Api::Film }
-  let(:data) { random_film }
-
-  before { WebMock.disable_net_connect! }
-  after { WebMock.allow_net_connect! }
-
-  describe '#id' do
-    subject { described_class.new(data).id }
-
-    it 'is a string' do
-      _(subject).must_be_instance_of(String)
-    end
-
-    it 'is the film id from the data' do
-      _(subject).must_equal(data['id'])
-    end
+class CineworldUk::Internal::Parser::Api::FilmTest < Minitest::Test
+  def test_id
+    assert_equal '014-1001', film.id
   end
 
-  describe '#dimension' do
-    subject { described_class.new(data).dimension }
-
-    it 'is a string' do
-      _(subject).must_be_instance_of(String)
-    end
-
-    it 'is 2d or 3d' do
-      _(subject).must_match(/[23]d/)
-    end
-
-    describe 'attributeIds includes "2d"' do
-      let(:data) { random_film.merge('attributeIds' => ['2d']) }
-
-      it 'is 2d' do
-        _(subject).must_equal('2d')
-      end
-    end
-
-    describe 'attributeIds includes "3d"' do
-      let(:data) { random_film.merge('attributeIds' => ['3d']) }
-
-      it 'is 3d' do
-        _(subject).must_equal('3d')
-      end
-    end
-
-    describe 'attributeIds with imax but not 3d' do
-      let(:data) { random_film.merge('attributeIds' => ['imax', '2d']) }
+  def test_dimension_defaults_to_2d
+    assert_equal '2d', film.dimension
+  end
 
-      it 'is 2d' do
-        _(subject).must_equal('2d')
-      end
-    end
+  def test_dimension_2d
+    assert_equal '2d', film('attributeIds' => ['2d']).dimension
+  end
 
-    describe 'attributeIds with imax and 3d' do
-      let(:data) { random_film.merge('attributeIds' => ['imax', '3d']) }
+  def test_dimension_3d
+    assert_equal '3d', film('attributeIds' => ['3d']).dimension
+  end
 
-      it 'is 3d' do
-        _(subject).must_equal('3d')
-      end
-    end
+  def test_dimension_imax_without_3d
+    assert_equal '2d', film('attributeIds' => %w(imax 2d)).dimension
   end
 
-  describe '#name' do
-    subject { described_class.new(data).name }
+  def test_dimension_imax_with_3d
+    assert_equal '3d', film('attributeIds' => %w(imax 3d)).dimension
+  end
 
-    it 'is a string' do
-      _(subject).must_be_instance_of(String)
-    end
+  def test_name
+    assert_equal 'Test Film Name', film('name' => 'Test Film Name').name
+  end
 
-    describe 'film name' do
-      let(:data) do
-        random_film.merge('name' => 'Test Film Name')
-      end
+  def test_name_is_sanitized
+    assert_equal 'Royal Opera House: Something', film('name' => 'ROH: Something').name
+  end
 
-      it 'is the film name' do
-        _(subject).must_equal('Test Film Name')
-      end
-    end
+  def test_name_drops_festival_prefix
+    assert_equal 'Scum Of The Earth', film('name' => 'Cine-Excess 2026: Scum Of The Earth').name
+  end
 
-    describe 'film name is unsanitized' do
-      let(:data) { random_film.merge('name' => 'ROH: Something') }
+  def test_festival
+    festival = film('name' => 'Cine-Excess 2026: Scum Of The Earth').festival(2026)
 
-      it 'is sanitized' do
-        _(subject).must_equal('Royal Opera House: Something')
-      end
-    end
+    assert_equal Cinebase::Festival.new(name: 'Cine-Excess', year: 2026), festival
   end
 
-  describe '#variant' do
-    subject { described_class.new(data).variant }
+  def test_festival_without_prefix
+    assert_nil film.festival(2026)
+  end
 
-    it 'is a sorted array of strings' do
-      _(subject).must_be_instance_of(Array)
-      subject.each { |element| _(element).must_be_instance_of(String) }
-      _(subject.sort).must_equal(subject)
-    end
+  def test_film_year
+    assert_equal 1996, film('name' => 'Horror Season 2026 From Dusk Till Dawn (1996)').film_year
+  end
 
-    describe 'attributeIds includes "junior"' do
-      let(:data) do
-        random_film.merge('attributeIds' => ['junior'])
-      end
+  def test_film_year_without_year
+    assert_nil film.film_year
+  end
 
-      it 'includes "kids"' do
-        _(subject).must_include('kids')
-      end
-    end
+  def test_variant_4dx
+    assert_includes film('attributeIds' => ['4dx']).variant, '4dx'
+  end
 
-    describe 'attributeIds includes "imax"' do
-      let(:data) do
-        random_film.merge('attributeIds' => ['imax', '3d'])
-      end
+  def test_variant_screenx
+    assert_includes film('attributeIds' => ['screenx']).variant, 'screenx'
+  end
 
-      it 'includes "imax"' do
-        _(subject).must_include('imax')
-      end
-    end
+  def test_variant_is_sorted
+    variant = film('attributeIds' => %w(qa junior imax)).variant
 
-    describe 'attributeIds includes "unlimited-screening"' do
-      let(:data) do
-        random_film.merge('attributeIds' => ['unlimited-screening'])
-      end
+    assert_equal variant.sort, variant
+  end
 
-      it 'includes "members"' do
-        _(subject).must_include('members')
-      end
-    end
+  def test_variant_junior_is_kids
+    assert_includes film('attributeIds' => ['junior']).variant, 'kids'
+  end
 
-    describe 'attributeIds includes "qa"' do
-      let(:data) do
-        random_film.merge('attributeIds' => ['qa'])
-      end
+  def test_variant_imax
+    assert_includes film('attributeIds' => %w(imax 3d)).variant, 'imax'
+  end
 
-      it 'includes "q&a"' do
-        _(subject).must_include('q&a')
-      end
-    end
+  def test_variant_unlimited_screening_is_members
+    assert_includes film('attributeIds' => ['unlimited-screening']).variant, 'members'
+  end
 
-    describe 'combination' do
-      let(:data) do
-        random_film.merge('attributeIds' => ['imax', 'unlimited-screening'])
-      end
+  def test_variant_q_and_a
+    assert_includes film('attributeIds' => ['qa']).variant, 'q&a'
+  end
 
-      it 'includes "members"' do
-        _(subject).must_include('imax', 'members')
-      end
-    end
+  def test_variant_combination
+    assert_equal %w(imax members), film('attributeIds' => %w(imax unlimited-screening)).variant
   end
 
   private
 
-  def random_film
-    JSON.parse(performances_tomorrow_json(14))['body']['films'].sample
+  def film(overrides = {})
+    data = { 'id' => '014-1001', 'name' => 'The Example Film', 'attributeIds' => [] }
+    CineworldUk::Internal::Parser::Api::Film.new(data.merge(overrides))
   end
 end

data/test/lib/cineworld_uk/internal/parser/api/performance_test.rb

@@ -1,62 +1,44 @@
 require_relative '../../../../../test_helper'
-require_relative '../../../../../support/fixture_reader'
 
-describe CineworldUk::Internal::Parser::Api::Performance do
-  include Support::FixtureReader
-
-  let(:described_class) { CineworldUk::Internal::Parser::Api::Performance }
-  let(:data) { random_performance }
-
-  before { WebMock.disable_net_connect! }
-  after { WebMock.allow_net_connect! }
-
-  describe '#booking_url' do
-    subject { described_class.new(data).booking_url }
-
-    it 'should be a url on the cineworld website' do
-      _(subject).must_match(%r{cineworld.co.uk})
-    end
+class CineworldUk::Internal::Parser::Api::PerformanceTest < Minitest::Test
+  def test_booking_url
+    assert_equal 'https://web.cineworld.co.uk/order/showtimes/014-1001/seats',
+                 performance.booking_url
   end
 
-  describe '#film_id' do
-    subject { described_class.new(data).film_id }
-
-    it 'should be a string' do
-      _(subject).must_be_instance_of(String)
-    end
+  def test_film_id
+    assert_equal '014-1001', performance.film_id
   end
 
-  describe '#starting_at' do
-    subject { described_class.new(data).starting_at }
-
-    it 'should be a time' do
-      _(subject).must_be_instance_of(Time)
-    end
+  def test_starting_at
+    assert_equal Time.utc(2026, 10, 24, 8, 0), performance.starting_at
   end
 
-  describe '#variant' do
-    subject { described_class.new(data).variant }
-
-    describe 'has "audio-described" in attributeIds' do
-      let(:data) { random_performance.merge('attributeIds' => ['audio-described']) }
+  def test_language
+    assert_equal 'Tamil', performance('language' => 'Tamil').language
+  end
 
-      it 'includes "audio_described"' do
-        _(subject).must_include('audio_described')
-      end
-    end
+  def test_language_defaults_to_nil
+    assert_nil performance.language
+  end
 
-    describe 'has "subbed" in attributeIds' do
-      let(:data) { random_performance.merge('attributeIds' => ['subbed']) }
+  def test_variant_audio_described
+    assert_includes performance('attributeIds' => ['audio-described']).variant, 'audio_described'
+  end
 
-      it 'includes "subtitled"' do
-        _(subject).must_include('subtitled')
-      end
-    end
+  def test_variant_subtitled
+    assert_includes performance('attributeIds' => ['subbed']).variant, 'subtitled'
   end
 
   private
 
-  def random_performance
-    JSON.parse(performances_tomorrow_json(14))['body']['events'].sample
+  def performance(overrides = {})
+    data = {
+      'filmId' => '014-1001',
+      'attributeIds' => [],
+      'eventDateTime' => '2026-10-24T08:00:00Z',
+      'bookingLink' => 'https://web.cineworld.co.uk/order/showtimes/014-1001/seats'
+    }
+    CineworldUk::Internal::Parser::Api::Performance.new(data.merge(overrides))
   end
 end