curzon_uk 1.0.0

data/test/fixtures/api/sites.json

@@ -0,0 +1,40 @@
+{
+  "sites": [
+    {
+      "id": "CAN2",
+      "name": { "text": "Canterbury" },
+      "contactDetails": {
+        "addressV2": {
+          "line1": { "text": "Unit 9," },
+          "line2": { "text": "The Example Riverside," },
+          "line3": { "text": "Canterbury, CT1 0ZZ" },
+          "line4": null
+        }
+      }
+    },
+    {
+      "id": "SOH1",
+      "name": { "text": "Soho" },
+      "contactDetails": {
+        "addressV2": {
+          "line1": { "text": "99 Example Avenue," },
+          "line2": { "text": "London," },
+          "line3": { "text": "W1D 0ZZ" },
+          "line4": null
+        }
+      }
+    },
+    {
+      "id": "VIC1",
+      "name": { "text": "Victoria" },
+      "contactDetails": {
+        "addressV2": {
+          "line1": { "text": "58 Example Street," },
+          "line2": { "text": "London," },
+          "line3": { "text": "SW1E 0ZZ " },
+          "line4": null
+        }
+      }
+    }
+  ]
+}

data/test/lib/curzon_uk/cinema_test.rb

@@ -0,0 +1,84 @@
+require_relative '../../test_helper'
+
+class CurzonUk::CinemaTest < Minitest::Test
+  def setup
+    @api_response = FakeApiResponse.new
+  end
+
+  def test_new_upcases_id
+    assert_equal 'SOH1', CurzonUk::Cinema.new('soh1').id
+  end
+
+  def test_all_returns_cinemas
+    with_fake_api do
+      cinemas = CurzonUk::Cinema.all
+
+      assert(cinemas.all? { |cinema| cinema.instance_of?(CurzonUk::Cinema) })
+      assert_equal %w(CAN2 SOH1 VIC1), cinemas.map(&:id)
+    end
+  end
+
+  def test_adr_strips_line_commas
+    expected = {
+      street_address:   '99 Example Avenue',
+      extended_address: nil,
+      locality:         'London',
+      region:           nil,
+      postal_code:      'W1D 0ZZ',
+      country_name:     'United Kingdom'
+    }
+
+    with_fake_api do
+      assert_equal expected, CurzonUk::Cinema.new('SOH1').adr
+      assert_equal expected, CurzonUk::Cinema.new('SOH1').address
+    end
+  end
+
+  def test_adr_with_town_and_postcode_on_one_line
+    with_fake_api do
+      adr = CurzonUk::Cinema.new('CAN2').adr
+
+      assert_equal 'Unit 9', adr[:street_address]
+      assert_equal 'The Example Riverside', adr[:extended_address]
+      assert_equal 'Canterbury', adr[:locality]
+      assert_equal 'CT1 0ZZ', adr[:postal_code]
+    end
+  end
+
+  def test_adr_trims_postcode
+    with_fake_api do
+      assert_equal 'SW1E 0ZZ', CurzonUk::Cinema.new('VIC1').postal_code
+    end
+  end
+
+  def test_brand_and_full_name
+    with_fake_api do
+      assert_equal 'Curzon', CurzonUk::Cinema.new('SOH1').brand
+      assert_equal 'Curzon Soho', CurzonUk::Cinema.new('SOH1').full_name
+    end
+  end
+
+  def test_name
+    with_fake_api do
+      assert_equal 'Soho', CurzonUk::Cinema.new('SOH1').name
+    end
+  end
+
+  def test_slug
+    with_fake_api do
+      assert_equal 'curzon-soho', CurzonUk::Cinema.new('SOH1').slug
+    end
+  end
+
+  def test_url
+    with_fake_api do
+      assert_equal 'https://www.curzon.com/venues/soho/', CurzonUk::Cinema.new('SOH1').url
+    end
+  end
+
+  private
+
+  def with_fake_api(&block)
+    CurzonUk::Internal::ApiResponse.stub(:new, @api_response, &block)
+  end
+end

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

@@ -0,0 +1,52 @@
+require_relative '../../../test_helper'
+
+class CurzonUk::Internal::ApiResponseTest < Minitest::Test
+  include ApiFixturesHelper
+
+  BASE_URL = 'https://digital-api.curzon.com/ocapi/v1'.freeze
+
+  def setup
+    CurzonUk.token = 'guest-jwt'
+  end
+
+  def teardown
+    CurzonUk.token = nil
+    super
+  end
+
+  def test_sites_sends_token_without_region
+    stub_request(:get, "#{BASE_URL}/sites")
+      .with { |request| request.headers['Authorization'] == 'Bearer guest-jwt' && !request.headers.key?('Connect-Region-Code') }
+      .to_return(status: 200, body: sites_json)
+
+    assert_equal %w(CAN2 SOH1 VIC1), api.sites.map { |site| site['id'] }
+  end
+
+  def test_showtimes
+    stub_request(:get, "#{BASE_URL}/showtimes/by-business-date/2026-10-24")
+      .with(query: { 'siteIds' => 'SOH1' })
+      .to_return(status: 200, body: showtimes_json('SOH1'))
+
+    showtimes = api.showtimes('SOH1', Date.new(2026, 10, 24))
+
+    assert_equal %w(businessDate relatedData showtimes), showtimes.keys.sort
+  end
+
+  def test_missing_token_raises_before_request
+    CurzonUk.token = nil
+
+    assert_raises(CurzonUk::AuthenticationError) { api.sites }
+  end
+
+  def test_rejected_token_raises
+    stub_request(:get, "#{BASE_URL}/sites").to_return(status: 401)
+
+    assert_raises(CurzonUk::AuthenticationError) { api.sites }
+  end
+
+  private
+
+  def api
+    CurzonUk::Internal::ApiResponse.new
+  end
+end

data/test/lib/curzon_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('SOH1')))
+  end
+end

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

@@ -0,0 +1,91 @@
+require_relative '../../../test_helper'
+require 'base64'
+require 'tmpdir'
+
+class CurzonUk::Internal::GuestTokenTest < Minitest::Test
+  def setup
+    @directory = Dir.mktmpdir('curzon-guest-token')
+  end
+
+  def teardown
+    FileUtils.remove_entry(@directory)
+    CurzonUk.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_accepts_the_not_found_page
+    token = token_expiring_at(Time.now + 3600)
+    curl = fake_curl("#{page_with(token)}\n404")
+
+    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(CurzonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_rejects_page_without_page_data
+    curl = fake_curl("<html></html>\n200")
+
+    assert_raises(CurzonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_rejects_redirect_to_queue
+    curl = fake_curl("\n302")
+
+    assert_raises(CurzonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_rejects_failed_command
+    curl = fake_curl('', exit_status: 7)
+
+    assert_raises(CurzonUk::AuthenticationError) { guest_token(curl).fetch }
+  end
+
+  def test_fetch_explains_missing_executable
+    error = assert_raises(CurzonUk::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)
+
+    CurzonUk.acquire_token!(curl: fake_curl("#{page_with(token)}\n200"))
+
+    assert_equal token, CurzonUk.token
+  end
+
+  private
+
+  def guest_token(curl)
+    CurzonUk::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://digital-api.curzon.com', '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/curzon_uk/internal/parser/api/showtime_test.rb

@@ -0,0 +1,59 @@
+require_relative '../../../../../test_helper'
+
+class CurzonUk::Internal::Parser::Api::ShowtimeTest < Minitest::Test
+  FILMS = {
+    'HO1' => { 'title' => { 'text' => 'Sense and Sensibility (2026)' } },
+    'HO2' => { 'title' => { 'text' => 'UKJFF - Example Gala' } }
+  }.freeze
+
+  ATTRIBUTES = {
+    '1' => { 'shortName' => { 'text' => 'Captioned' }, 'name' => { 'text' => 'Open Captioned' } },
+    '2' => { 'shortName' => { 'text' => 'Baby Club' }, 'name' => { 'text' => 'Baby Club' } },
+    '3' => { 'shortName' => { 'text' => 'Q&A' }, 'name' => { 'text' => 'Screening followed by a Q&A' } },
+    '4' => { 'shortName' => { 'text' => 'Atmos' }, 'name' => { 'text' => 'Atmos' } }
+  }.freeze
+
+  def test_to_hash
+    expected = {
+      booking_url: 'https://www.curzon.com/ticketing/seats/?showtimeId=SOH1-1',
+      dimension: '2d',
+      festival: nil,
+      film_name: 'Sense and Sensibility',
+      film_year: 2026,
+      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_maps_attribute_names_to_variants
+    assert_equal %w(subtitled baby q&a), parse(attribute_ids: %w(1 2 3 4))[:variant]
+  end
+
+  def test_festival
+    showtime = parse(film_id: 'HO2')
+
+    assert_equal Cinebase::Festival.new(name: 'UKJFF', year: 2026), showtime[:festival]
+    assert_equal 'Example Gala', showtime[:film_name]
+  end
+
+  private
+
+  def parse(attribute_ids: [], requires3d: false, film_id: 'HO1')
+    data = {
+      'id' => 'SOH1-1',
+      'filmId' => film_id,
+      'schedule' => { 'startsAt' => '2026-10-24T18:30:00+01:00' },
+      'attributeIds' => attribute_ids,
+      'requires3dGlasses' => requires3d
+    }
+    CurzonUk::Internal::Parser::Api::Showtime.new(
+      data, films: FILMS, attributes: ATTRIBUTES
+    ).to_hash
+  end
+end

data/test/lib/curzon_uk/internal/title_sanitizer_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../../test_helper'
+
+class CurzonUk::Internal::TitleSanitizerTest < Minitest::Test
+  def test_removes_dochouse_strand
+    assert_sanitized 'Derek Vs Derek', 'DocHouse: Derek Vs Derek'
+  end
+
+  def test_removes_film_club_strand
+    assert_sanitized 'Black Beyond: Welcome II The Terrordome',
+                     'Film Club: Black Beyond: Welcome II The Terrordome'
+  end
+
+  def test_removes_film_year
+    assert_sanitized 'Street Fighter', 'Street Fighter (2026)'
+  end
+
+  def test_keeps_titles_with_their_own_subtitles
+    [
+      'De Gaulle: Part 2- Liberte',
+      'Ghosts: The Possession of Button House',
+      'Hadestown: The Musical',
+      'Fallen Angels by Noël Coward'
+    ].each { |title| assert_sanitized title, title }
+  end
+
+  private
+
+  def assert_sanitized(expected, title)
+    assert_equal expected, CurzonUk::Internal::TitleSanitizer.new(title).sanitized
+  end
+end

data/test/lib/curzon_uk/performance_test.rb

@@ -0,0 +1,106 @@
+require_relative '../../test_helper'
+
+class CurzonUk::PerformanceTest < Minitest::Test
+  DATE = Date.new(2026, 10, 24)
+
+  def setup
+    @api_response = FakeApiResponse.new
+  end
+
+  def test_at_returns_performances
+    performances = performances_at('SOH1')
+
+    assert(performances.all? { |p| p.instance_of?(CurzonUk::Performance) })
+    assert_equal 5, performances.count
+  end
+
+  def test_at_accepts_lower_case_id
+    assert_equal 5, performances_at('soh1').count
+  end
+
+  def test_at_sets_cinema_details
+    performances = performances_at('SOH1')
+
+    assert_equal ['SOH1'], performances.map(&:cinema_id).uniq
+    assert_equal ['Soho'], performances.map(&:cinema_name).uniq
+  end
+
+  def test_at_parses_first_performance
+    performance = performances_at('SOH1').first
+
+    assert_equal 'The Example Film', performance.film_name
+    assert_equal Time.utc(2026, 10, 24, 12, 0), performance.starting_at
+    assert_equal '2d', performance.dimension
+    assert_equal [], performance.variant
+    assert_equal 'https://www.curzon.com/ticketing/seats/?showtimeId=SOH1-1001', performance.booking_url
+  end
+
+  def test_at_parses_3d_open_captions
+    performance = performances_at('SOH1')[1]
+
+    assert_equal '3d', performance.dimension
+    assert performance.subtitled?
+  end
+
+  def test_at_strips_strand_and_year
+    performance = performances_at('SOH1')[2]
+
+    assert_equal 'A Made Up Documentary', performance.film_name
+    assert_equal 2025, performance.film_year
+    assert_equal %w(q&a), performance.variant
+  end
+
+  def test_at_strips_film_club
+    performance = performances_at('SOH1')[3]
+
+    assert_equal 'Pretend Classic', performance.film_name
+    assert_equal %w(baby), performance.variant
+  end
+
+  def test_at_moves_festival_from_title
+    performance = performances_at('SOH1')[4]
+
+    assert_equal 'Imaginary Picture', performance.film_name
+    assert_equal Cinebase::Festival.new(name: 'UKJFF', year: 2026), performance.festival
+  end
+
+  def test_at_keeps_after_midnight_on_next_utc_day
+    assert_equal Time.utc(2026, 10, 24, 23, 15), performances_at('SOH1').last.starting_at
+  end
+
+  def test_at_requests_each_date_in_range
+    to = DATE + 2
+
+    with_fake_api { CurzonUk::Performance.at('SOH1', from: DATE, to: to) }
+
+    assert_equal (DATE..to).to_a, @api_response.requested_dates
+  end
+
+  def test_at_rejects_range_ending_before_start
+    assert_raises(ArgumentError) { CurzonUk::Performance.at('SOH1', from: DATE, to: DATE - 1) }
+  end
+
+  def test_new_sets_defaults
+    performance = CurzonUk::Performance.new(
+      film_name: 'Carol', cinema_id: 'SOH1', cinema_name: 'Soho',
+      starting_at: Time.utc(2013, 9, 12, 11, 0)
+    )
+
+    assert_nil performance.booking_url
+    assert_equal '2d', performance.dimension
+    assert_nil performance.festival
+    assert_nil performance.film_year
+    refute performance.subtitled?
+    assert_equal [], performance.variant
+  end
+
+  private
+
+  def performances_at(cinema_id)
+    with_fake_api { CurzonUk::Performance.at(cinema_id, from: DATE, to: DATE) }
+  end
+
+  def with_fake_api(&block)
+    CurzonUk::Internal::ApiResponse.stub(:new, @api_response, &block)
+  end
+end

data/test/lib/curzon_uk/version_test.rb

@@ -0,0 +1,7 @@
+require_relative '../../test_helper'
+
+class CurzonUk::VersionTest < Minitest::Test
+  def test_version_is_defined
+    refute_nil CurzonUk::VERSION
+  end
+end

data/test/live/api_shape_test.rb

@@ -0,0 +1,19 @@
+require_relative 'live_helper'
+
+class LiveApiShapeTest < Minitest::Test
+  include ApiShapes
+
+  def test_sites_are_readable
+    assert_sites_shape('sites' => api.sites)
+  end
+
+  def test_showtimes_are_readable
+    assert_showtimes_shape(api.showtimes('SOH1', Date.today + 1))
+  end
+
+  private
+
+  def api
+    CurzonUk::Internal::ApiResponse.new
+  end
+end

data/test/live/integration_test.rb

@@ -0,0 +1,27 @@
+require_relative 'live_helper'
+
+class LiveCinemaTest < Minitest::Test
+  def test_all_returns_cinemas
+    cinemas = CurzonUk::Cinema.all
+
+    assert(cinemas.all? { |cinema| cinema.instance_of?(CurzonUk::Cinema) })
+    assert_operator cinemas.size, :>, 10
+    assert_equal 'Soho', cinemas.detect { |cinema| cinema.id == 'SOH1' }.name
+  end
+
+  def test_every_cinema_has_a_postcode
+    CurzonUk::Cinema.all.each do |cinema|
+      refute_empty cinema.postal_code, "#{cinema.id} #{cinema.name}"
+    end
+  end
+end
+
+class LivePerformanceTest < Minitest::Test
+  def test_at_returns_performances
+    tomorrow = Date.today + 1
+    performances = CurzonUk::Performance.at('SOH1', from: tomorrow, to: tomorrow)
+
+    assert(performances.all? { |p| p.instance_of?(CurzonUk::Performance) })
+    assert_operator performances.count, :>, 3
+  end
+end

data/test/live/live_helper.rb

@@ -0,0 +1,11 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+Minitest::Reporters.use! [
+  Minitest::Reporters::DefaultReporter.new(color: true)
+]
+
+require File.expand_path('../../../lib/curzon_uk.rb', __FILE__)
+require_relative '../support/api_shapes'
+
+CurzonUk.token = ENV.fetch('CURZON_TOKEN') { CurzonUk.acquire_token! }

data/test/package_test.rb

@@ -0,0 +1,56 @@
+# Run separately after building: CURZON_PACKAGE=pkg/...gem bundle exec ruby test/package_test.rb
+require "minitest/autorun"
+require "rubygems/installer"
+require "tmpdir"
+require "fileutils"
+require "open3"
+require "base64"
+require "json"
+
+class PlatformPackageTest < Minitest::Test
+  def setup
+    @directory = Dir.mktmpdir("curzon-package-test")
+    @spec = Gem::Installer.at(
+      ENV.fetch("CURZON_PACKAGE"), install_dir: @directory, ignore_dependencies: true
+    ).install
+    @vendor = File.join(@spec.full_gem_path, "vendor", "curl-impersonate")
+    @binary = File.join(@vendor, "bin", "curl-impersonate")
+  end
+
+  def teardown
+    FileUtils.remove_entry(@directory)
+  end
+
+  def test_installs_runnable_executable_with_notices_and_provenance
+    assert File.executable?(@binary)
+    output, status = Open3.capture2(@binary, "--version")
+    assert status.success?
+    assert_includes output, "curl"
+    assert File.file?(File.join(@vendor, "licenses", "LICENSE_CURL"))
+    assert_includes File.read(File.join(@vendor, "SOURCE")), "2.2.3"
+  end
+
+  def test_acquires_token_with_gem_local_executable_and_no_curl_on_path
+    payload = Base64.urlsafe_encode64(JSON.generate("exp" => Time.now.to_i + 3600), padding: false)
+    token = "header.#{payload}.signature"
+    data = { "api" => { "authToken" => token } }
+    page = "<script>\nwindow.initialData = #{JSON.generate(data)};\n</script>\n200"
+    # Substitute only the network response, not the installed package's path resolution.
+    File.write(@binary, "#!#{RbConfig.ruby}\nSTDOUT.write(#{page.dump})\n")
+    output, error, status = Open3.capture3(
+      { "PATH" => @directory, "RUBYOPT" => nil, "BUNDLER_SETUP" => nil,
+        "GEM_PATH" => Gem.path.join(File::PATH_SEPARATOR) }, RbConfig.ruby,
+      "-I#{File.join(@spec.full_gem_path, 'lib')}", *cinebase_load_path, "-rcurzon_uk",
+      "-e", "print CurzonUk.acquire_token!"
+    )
+    assert status.success?, error
+    assert_equal token, output
+  end
+
+  private
+
+  # The package is installed without dependencies, so load the bundle's cinebase.
+  def cinebase_load_path
+    Gem.loaded_specs.fetch("cinebase").full_require_paths.map { |path| "-I#{path}" }
+  end
+end

data/test/support/api_fixtures_helper.rb

@@ -0,0 +1,17 @@
+# Read hand-written fixtures from disk. They follow the shape in
+# api_shapes.rb; they are never recorded API output.
+module ApiFixturesHelper
+  private
+
+  def sites_json
+    read_fixture('api/sites')
+  end
+
+  def showtimes_json(cinema_id)
+    read_fixture("api/showtimes-#{cinema_id}")
+  end
+
+  def read_fixture(filepath)
+    File.read(File.expand_path("../../fixtures/#{filepath}.json", __FILE__))
+  end
+end

data/test/support/api_shapes.rb

@@ -0,0 +1,48 @@
+require 'time'
+
+# The parts of Vista responses the gem reads. Checked against the hand-written
+# fixtures and, in the live suite, against real responses held only in memory.
+module ApiShapes
+  private
+
+  def assert_sites_shape(data)
+    sites = data.fetch('sites')
+    refute_empty sites
+    sites.each do |site|
+      assert_match(/\A[A-Z0-9]+\z/, site.fetch('id'))
+      assert_kind_of String, site.dig('name', 'text')
+      address = site.fetch('contactDetails').fetch('addressV2')
+      %w(line1 line2 line3 line4).each do |key|
+        line = address.fetch(key)
+        assert_kind_of String, line.fetch('text'), "site #{site['id']} #{key}" unless line.nil?
+      end
+    end
+  end
+
+  def assert_showtimes_shape(data)
+    related = data.fetch('relatedData')
+    films = related.fetch('films').to_h { |film| [film.fetch('id'), film] }
+    attributes = related.fetch('attributes').to_h do |attribute|
+      [attribute.fetch('id'), attribute]
+    end
+
+    films.each_value { |film| assert_kind_of String, film.dig('title', 'text') }
+    attributes.each_value do |attribute|
+      assert_kind_of String, attribute.dig('shortName', 'text')
+      assert_kind_of String, attribute.dig('name', 'text')
+    end
+    related.fetch('sites').each { |site| assert_kind_of String, site.dig('name', 'text') }
+
+    showtimes = data.fetch('showtimes')
+    refute_empty showtimes
+    showtimes.each do |showtime|
+      assert_kind_of String, showtime.fetch('id')
+      assert_includes films.keys, showtime.fetch('filmId')
+      assert_kind_of Time, Time.iso8601(showtime.fetch('schedule').fetch('startsAt'))
+      assert_includes [true, false], showtime.fetch('requires3dGlasses')
+      showtime.fetch('attributeIds').each do |id|
+        assert_includes attributes.keys, id
+      end
+    end
+  end
+end