vue_uk 1.0.0

data/test/fixtures/api/films-10051.json

@@ -0,0 +1,103 @@
+{
+  "result": [
+    {
+      "filmId": "HO1",
+      "filmTitle": "The Example Film",
+      "showingGroups": [
+        {
+          "date": "2026-10-24T00:00:00",
+          "sessions": [
+            {
+              "sessionId": "1001",
+              "bookingUrl": "/book-tickets/summary/10051/HO1/1001",
+              "showTimeWithTimeZone": "2026-10-24T10:30:00+01:00",
+              "attributes": [
+                { "name": "English", "shortName": "", "value": "english" },
+                { "name": "Audio Description (AD)", "shortName": "AD", "value": "audio" }
+              ]
+            },
+            {
+              "sessionId": "1002",
+              "bookingUrl": "/book-tickets/summary/10051/HO1/1002",
+              "showTimeWithTimeZone": "2026-10-24T14:00:00+01:00",
+              "attributes": [
+                { "name": "3D", "shortName": "3D", "value": "3d" }
+              ]
+            }
+          ]
+        },
+        {
+          "date": "2026-10-25T00:00:00",
+          "sessions": [
+            {
+              "sessionId": "1009",
+              "bookingUrl": "/book-tickets/summary/10051/HO1/1009",
+              "showTimeWithTimeZone": "2026-10-25T10:30:00+00:00",
+              "attributes": []
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "filmId": "HO2",
+      "filmTitle": "Imaginary Picture (2026) (Tamil)",
+      "showingGroups": [
+        {
+          "date": "2026-10-24T00:00:00",
+          "sessions": [
+            {
+              "sessionId": "1003",
+              "bookingUrl": "/book-tickets/summary/10051/HO2/1003",
+              "showTimeWithTimeZone": "2026-10-24T18:00:00+01:00",
+              "attributes": [
+                { "name": "Tamil", "shortName": "Tamil", "value": "tamil" },
+                { "name": "Open Captioned", "shortName": "Open Captioned", "value": "open-captioned" }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "filmId": "HO3",
+      "filmTitle": "Mystery Screening (24 October 2026)",
+      "showingGroups": [
+        {
+          "date": "2026-10-24T00:00:00",
+          "sessions": [
+            {
+              "sessionId": "1004",
+              "bookingUrl": "/book-tickets/summary/10051/HO3/1004",
+              "showTimeWithTimeZone": "2026-10-24T11:00:00+01:00",
+              "attributes": [
+                { "name": "Mighty Mornings", "shortName": "Mighty Mornings", "value": "mightymornings" }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "filmId": "HO4",
+      "filmTitle": "CFF: Made Up Matinee",
+      "showingGroups": [
+        {
+          "date": "2026-10-24T00:00:00",
+          "sessions": [
+            {
+              "sessionId": "1005",
+              "bookingUrl": "/book-tickets/summary/10051/HO4/1005",
+              "showTimeWithTimeZone": "2026-10-25T00:15:00+01:00",
+              "attributes": [
+                { "name": "Big Screen Events", "shortName": "", "value": "big-screen-events" }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "responseCode": 0,
+  "errorMessage": null
+}

data/test/fixtures/website/cinema-10051.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html lang="en">
+<head><title>Vue Accrington</title></head>
+<body>
+<div id="__next"></div>
+<script id="__NEXT_DATA__" type="application/json">{"props":{"pageProps":{"layoutData":{"sitecore":{"context":{"cinema":{"cinemaId":{"value":"10051"},"cinemaName":{"value":"Accrington"},"cinemaAddress":{"value":"1 Example Viaduct\r\nExample Road\r\nAccrington\r\nBB5 0ZZ       "}}}}}}}}</script>
+</body>
+</html>

data/test/lib/vue_uk/cinema_test.rb

@@ -0,0 +1,110 @@
+require_relative '../../test_helper'
+
+class VueUk::CinemaTest < Minitest::Test
+  def setup
+    @api_response = FakeApiResponse.new
+    VueUk::Cinema.instance_variable_set(:@cinemas_hash, nil)
+  end
+
+  def test_new_stores_string_id
+    assert_equal '10051', VueUk::Cinema.new(10051).id
+  end
+
+  def test_all_returns_uk_cinemas
+    with_fakes do
+      cinemas = VueUk::Cinema.all
+
+      assert(cinemas.all? { |cinema| cinema.instance_of?(VueUk::Cinema) })
+      assert_equal %w(10051 10015), cinemas.map(&:id)
+    end
+  end
+
+  def test_name_and_full_name
+    with_fakes do
+      assert_equal 'Accrington', VueUk::Cinema.new(10051).name
+      assert_equal 'Vue Birmingham (Star City)', VueUk::Cinema.new(10015).full_name
+    end
+  end
+
+  def test_brand
+    assert_equal 'Vue', VueUk::Cinema.new(10051).brand
+  end
+
+  def test_slug
+    with_fakes do
+      assert_equal 'vue-birmingham-star-city', VueUk::Cinema.new(10015).slug
+    end
+  end
+
+  def test_url
+    with_fakes do
+      assert_equal 'https://www.myvue.com/cinema/accrington', VueUk::Cinema.new(10051).url
+    end
+  end
+
+  def test_adr_from_cinema_page
+    expected = {
+      street_address:   '1 Example Viaduct',
+      extended_address: 'Example Road',
+      locality:         'Accrington',
+      region:           nil,
+      postal_code:      'BB5 0ZZ',
+      country_name:     'United Kingdom'
+    }
+
+    with_fakes do
+      assert_equal expected, VueUk::Cinema.new(10051).adr
+      assert_equal 'BB5 0ZZ', VueUk::Cinema.new(10051).postal_code
+    end
+  end
+
+  def test_adr_with_country_after_postcode
+    website = Object.new
+    website.define_singleton_method(:cinema) do |_url|
+      { 'cinemaAddress' => { 'value' => "2 Example Park\r\nExample Rd, Barrow-in-Furness\r\nLA14 0ZZ, UK" } }
+    end
+
+    VueUk::Internal::ApiResponse.stub(:new, @api_response) do
+      VueUk::Internal::Website.stub(:new, website) do
+        adr = VueUk::Cinema.new(10051).adr
+
+        assert_equal 'LA14 0ZZ', adr[:postal_code]
+        assert_equal 'Example Rd, Barrow-in-Furness', adr[:locality]
+        assert_equal '2 Example Park', adr[:street_address]
+      end
+    end
+  end
+
+  def test_adr_with_county_before_postcode
+    adr = adr_for("1 Example Park\r\nExample Way\r\nColchester\r\nEssex CO4 0ZZ")
+
+    assert_equal 'CO4 0ZZ', adr[:postal_code]
+    assert_equal 'Essex', adr[:region]
+    assert_equal 'Colchester', adr[:locality]
+  end
+
+  def test_adr_ignores_map_coordinates
+    adr = adr_for("O2 Example Centre\r\n255 Example Road\r\nLondon\r\n51.548, -0.181")
+
+    assert_nil adr[:postal_code]
+    assert_equal 'London', adr[:locality]
+    assert_equal '255 Example Road', adr[:extended_address]
+  end
+
+  private
+
+  def adr_for(address)
+    website = Object.new
+    website.define_singleton_method(:cinema) { |_url| { 'cinemaAddress' => { 'value' => address } } }
+
+    VueUk::Internal::ApiResponse.stub(:new, @api_response) do
+      VueUk::Internal::Website.stub(:new, website) { VueUk::Cinema.new(10051).adr }
+    end
+  end
+
+  def with_fakes(&block)
+    VueUk::Internal::ApiResponse.stub(:new, @api_response) do
+      VueUk::Internal::Website.stub(:new, FakeWebsite.new, &block)
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require_relative '../../../test_helper'
+
+class VueUk::Internal::ApiResponseTest < Minitest::Test
+  include FixturesHelper
+
+  BASE_URL = 'https://www.myvue.com/api/microservice'.freeze
+  FILMS_QUERY = { 'minEmbargoLevel' => '3', 'includesSession' => 'true', 'includeSessionAttributes' => 'true' }.freeze
+
+  def setup
+    @session = stub_request(:post, "#{BASE_URL}/auth/token")
+               .to_return(status: 200, body: '{}', headers: { 'Set-Cookie' => ['accessToken=abc; HttpOnly; Path=/', 'refreshToken=def; HttpOnly; Path=/'] })
+  end
+
+  def test_cinemas_sends_guest_session_cookies
+    stub_request(:get, "#{BASE_URL}/showings/cinemas")
+      .with(headers: { 'Accept' => 'application/json', 'Cookie' => 'accessToken=abc; refreshToken=def' })
+      .to_return(status: 200, body: cinemas_json)
+
+    assert_equal %w(10051 10015 90001), api.cinemas.map { |cinema| cinema['cinemaId'] }
+  end
+
+  def test_films_for_all_dates
+    stub_request(:get, "#{BASE_URL}/showings/cinemas/10051/films")
+      .with(query: FILMS_QUERY)
+      .to_return(status: 200, body: films_json('10051'))
+
+    assert_equal 'The Example Film', api.films('10051').first['filmTitle']
+  end
+
+  def test_reuses_one_session
+    stub_request(:get, "#{BASE_URL}/showings/cinemas").to_return(status: 200, body: cinemas_json)
+    client = api
+
+    2.times { client.cinemas }
+
+    assert_requested @session, times: 1
+  end
+
+  def test_starts_a_fresh_session_once_when_rejected
+    stub_request(:get, "#{BASE_URL}/showings/cinemas")
+      .to_return({ status: 401 }, { status: 200, body: cinemas_json })
+
+    assert_equal 3, api.cinemas.size
+    assert_requested @session, times: 2
+  end
+
+  def test_raises_when_a_fresh_session_is_rejected_too
+    stub_request(:get, "#{BASE_URL}/showings/cinemas").to_return(status: 401, body: 'secret')
+
+    error = assert_raises(VueUk::Internal::Http::Unauthorized) { api.cinemas }
+
+    assert_equal 'Vue HTTP error 401', error.message
+  end
+
+  def test_other_errors_omit_body
+    stub_request(:get, "#{BASE_URL}/showings/cinemas").to_return(status: 500, body: 'secret')
+
+    error = assert_raises(RuntimeError) { api.cinemas }
+
+    assert_equal 'Vue HTTP error 500', error.message
+  end
+
+  private
+
+  def api
+    VueUk::Internal::ApiResponse.new
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative '../../../test_helper'
+
+class FixtureShapeTest < Minitest::Test
+  include ApiShapes
+  include FixturesHelper
+
+  def test_cinemas_fixture_matches_shape
+    assert_cinemas_shape(JSON.parse(cinemas_json))
+  end
+
+  def test_films_fixture_matches_shape
+    assert_films_shape(JSON.parse(films_json('10051')))
+  end
+
+  def test_cinema_page_fixture_matches_shape
+    assert_cinema_page_shape(FakeWebsite.new.cinema('https://www.myvue.com/cinema/accrington/whats-on'))
+  end
+end

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

@@ -0,0 +1,44 @@
+require_relative '../../../../../test_helper'
+
+class VueUk::Internal::Parser::Api::ShowtimeTest < Minitest::Test
+  def test_to_hash
+    expected = {
+      booking_url: 'https://www.myvue.com/book-tickets/summary/10051/HO1/1',
+      dimension: '2d',
+      festival: nil,
+      film_name: 'From Dusk Till Dawn',
+      film_year: 1996,
+      language: nil,
+      starting_at: Time.utc(2026, 10, 24, 17, 30),
+      variant: []
+    }
+
+    assert_equal expected, parse
+  end
+
+  def test_language_includes_english
+    assert_equal 'English', parse(attributes: ['English'])[:language]
+  end
+
+  def test_maps_attribute_names_to_variants
+    variant = parse(attributes: ['Autism Friendly', 'Big Shorts', 'Laser', 'Single Seat'])[:variant]
+
+    assert_equal %w(autism_friendly kids), variant
+  end
+
+  def test_missing_booking_url
+    assert_nil parse(booking_url: nil)[:booking_url]
+  end
+
+  private
+
+  def parse(attributes: [], booking_url: '/book-tickets/summary/10051/HO1/1')
+    session = {
+      'bookingUrl' => booking_url,
+      'showTimeWithTimeZone' => '2026-10-24T18:30:00+01:00',
+      'attributes' => attributes.map { |name| { 'name' => name } }
+    }
+    film = { 'filmTitle' => 'From Dusk Till Dawn (1996)' }
+    VueUk::Internal::Parser::Api::Showtime.new(session, film: film).to_hash
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative '../../../test_helper'
+
+class VueUk::Internal::TitleSanitizerTest < Minitest::Test
+  def test_removes_screening_date
+    assert_sanitized 'Mystery Screening', 'Mystery Screening (23 October 2026)'
+  end
+
+  def test_removes_language_version
+    assert_sanitized 'Jailer 2', 'Jailer 2 (Tamil)'
+  end
+
+  def test_removes_film_year
+    assert_sanitized 'Street Fighter', 'Street Fighter (2026)'
+  end
+
+  def test_keeps_titles_with_their_own_subtitles
+    [
+      'Ghosts: The Possession of Button House',
+      'Spider-Man: Brand New Day',
+      "We're Going on a Bear Hunt + The Tiger Who Came to Tea",
+      'Blade Runner 2049'
+    ].each { |title| assert_sanitized title, title }
+  end
+
+  private
+
+  def assert_sanitized(expected, title)
+    assert_equal expected, VueUk::Internal::TitleSanitizer.new(title).sanitized
+  end
+end

data/test/lib/vue_uk/internal/website_test.rb

@@ -0,0 +1,22 @@
+require_relative '../../../test_helper'
+
+class VueUk::Internal::WebsiteTest < Minitest::Test
+  include FixturesHelper
+
+  URL = 'https://www.myvue.com/cinema/accrington/whats-on'.freeze
+
+  def test_cinema_reads_page_data
+    stub_request(:get, URL).to_return(status: 200, body: cinema_page_html('10051'))
+
+    cinema = VueUk::Internal::Website.new.cinema(URL)
+
+    assert_equal "1 Example Viaduct\r\nExample Road\r\nAccrington\r\nBB5 0ZZ       ",
+                 cinema.dig('cinemaAddress', 'value')
+  end
+
+  def test_cinema_without_page_data_is_empty
+    stub_request(:get, URL).to_return(status: 200, body: '<script id="__NEXT_DATA__">{}</script>')
+
+    assert_equal({}, VueUk::Internal::Website.new.cinema(URL))
+  end
+end

data/test/lib/vue_uk/performance_test.rb

@@ -0,0 +1,108 @@
+require_relative '../../test_helper'
+
+class VueUk::PerformanceTest < Minitest::Test
+  DATE = Date.new(2026, 10, 24)
+
+  def setup
+    @api_response = FakeApiResponse.new
+    VueUk::Cinema.instance_variable_set(:@cinemas_hash, nil)
+  end
+
+  def test_at_returns_performances_on_the_requested_date_only
+    performances = performances_at(10051)
+
+    assert(performances.all? { |p| p.instance_of?(VueUk::Performance) })
+    assert_equal 5, performances.count
+  end
+
+  def test_at_accepts_string_id
+    assert_equal 5, performances_at('10051').count
+  end
+
+  def test_at_sets_cinema_details
+    performances = performances_at(10051)
+
+    assert_equal ['10051'], performances.map(&:cinema_id).uniq
+    assert_equal ['Accrington'], performances.map(&:cinema_name).uniq
+  end
+
+  def test_at_parses_first_performance
+    performance = performances_at(10051).first
+
+    assert_equal 'The Example Film', performance.film_name
+    assert_equal Time.utc(2026, 10, 24, 9, 30), performance.starting_at
+    assert_equal '2d', performance.dimension
+    assert_equal 'English', performance.language
+    assert_equal %w(audio_described), performance.variant
+    assert_equal 'https://www.myvue.com/book-tickets/summary/10051/HO1/1001', performance.booking_url
+  end
+
+  def test_at_parses_3d
+    assert_equal '3d', performances_at(10051)[1].dimension
+  end
+
+  def test_at_moves_year_and_language_from_title
+    performance = performances_at(10051)[2]
+
+    assert_equal 'Imaginary Picture', performance.film_name
+    assert_equal 2026, performance.film_year
+    assert_equal 'Tamil', performance.language
+    assert performance.subtitled?
+  end
+
+  def test_at_strips_screening_date
+    performance = performances_at(10051)[3]
+
+    assert_equal 'Mystery Screening', performance.film_name
+    assert_equal %w(kids), performance.variant
+  end
+
+  def test_at_moves_festival_from_title
+    performance = performances_at(10051)[4]
+
+    assert_equal 'Made Up Matinee', performance.film_name
+    assert_equal Cinebase::Festival.new(name: 'CFF', year: 2026), performance.festival
+    assert_equal %w(arts), performance.variant
+  end
+
+  def test_at_keeps_after_midnight_on_next_utc_day
+    assert_equal Time.utc(2026, 10, 24, 23, 15), performances_at(10051).last.starting_at
+  end
+
+  def test_at_filters_one_request_to_the_date_range
+    performances = with_fake_api { VueUk::Performance.at(10051, from: DATE, to: DATE + 1) }
+
+    assert_equal 6, performances.count
+    assert_includes performances.map(&:starting_at), Time.utc(2026, 10, 25, 10, 30)
+    assert_equal 1, @api_response.requests
+  end
+
+  def test_at_rejects_range_ending_before_start
+    assert_raises(ArgumentError) { VueUk::Performance.at(10051, from: DATE, to: DATE - 1) }
+  end
+
+  def test_new_sets_defaults
+    performance = VueUk::Performance.new(
+      film_name: 'Carol', cinema_id: '10051', cinema_name: 'Accrington',
+      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
+    assert_nil performance.language
+    refute performance.subtitled?
+    assert_equal [], performance.variant
+  end
+
+  private
+
+  def performances_at(cinema_id)
+    with_fake_api { VueUk::Performance.at(cinema_id, from: DATE, to: DATE) }
+  end
+
+  def with_fake_api(&block)
+    VueUk::Internal::ApiResponse.stub(:new, @api_response, &block)
+  end
+end

data/test/lib/vue_uk/version_test.rb

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

data/test/live/api_shape_test.rb

@@ -0,0 +1,17 @@
+require_relative 'live_helper'
+
+class LiveApiShapeTest < Minitest::Test
+  include ApiShapes
+
+  def test_cinemas_are_readable
+    assert_cinemas_shape('result' => [{ 'cinemas' => VueUk::Internal::ApiResponse.new.cinemas }])
+  end
+
+  def test_films_are_readable
+    assert_films_shape('result' => VueUk::Internal::ApiResponse.new.films('10051'))
+  end
+
+  def test_cinema_page_is_readable
+    assert_cinema_page_shape(VueUk::Internal::Website.new.cinema('https://www.myvue.com/cinema/accrington/whats-on'))
+  end
+end

data/test/live/integration_test.rb

@@ -0,0 +1,25 @@
+require_relative 'live_helper'
+
+class LiveCinemaTest < Minitest::Test
+  def test_all_returns_cinemas
+    cinemas = VueUk::Cinema.all
+
+    assert(cinemas.all? { |cinema| cinema.instance_of?(VueUk::Cinema) })
+    assert_operator cinemas.size, :>, 70
+    assert_equal 'Accrington', cinemas.detect { |cinema| cinema.id == '10051' }.name
+  end
+
+  def test_address_has_a_postcode
+    refute_empty VueUk::Cinema.new(10051).postal_code
+  end
+end
+
+class LivePerformanceTest < Minitest::Test
+  def test_at_returns_performances
+    tomorrow = Date.today + 1
+    performances = VueUk::Performance.at(10051, from: tomorrow, to: tomorrow)
+
+    assert(performances.all? { |p| p.instance_of?(VueUk::Performance) })
+    assert_operator performances.count, :>, 5
+  end
+end

data/test/live/live_helper.rb

@@ -0,0 +1,9 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+Minitest::Reporters.use! [
+  Minitest::Reporters::DefaultReporter.new(color: true)
+]
+
+require File.expand_path('../../../lib/vue_uk.rb', __FILE__)
+require_relative '../support/api_shapes'

data/test/support/api_shapes.rb

@@ -0,0 +1,38 @@
+require 'time'
+
+# The parts of Vue 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_cinemas_shape(data)
+    cinemas = data.fetch('result').flat_map { |group| group.fetch('cinemas') }
+    refute_empty cinemas
+    cinemas.each do |cinema|
+      assert_match(/\A\d+\z/, cinema.fetch('cinemaId'))
+      assert_kind_of String, cinema.fetch('cinemaName')
+      assert_kind_of String, cinema.fetch('venueCurrency')
+      assert_match(%r{\Ahttps://www\.myvue\.com/cinema/[a-z0-9-]+/whats-on\z}, cinema.fetch('whatsOnUrl'))
+    end
+  end
+
+  def assert_films_shape(data)
+    films = data.fetch('result')
+    refute_empty films
+    films.each do |film|
+      assert_kind_of String, film.fetch('filmTitle')
+      film.fetch('showingGroups').each do |group|
+        assert_match(/\A\d{4}-\d{2}-\d{2}T/, group.fetch('date'))
+        group.fetch('sessions').each do |session|
+          assert_kind_of Time, Time.iso8601(session.fetch('showTimeWithTimeZone'))
+          assert_match(%r{\A/}, session.fetch('bookingUrl'))
+          session.fetch('attributes').each { |attribute| assert_kind_of String, attribute.fetch('name') }
+        end
+      end
+    end
+  end
+
+  def assert_cinema_page_shape(cinema)
+    assert_kind_of String, cinema.fetch('cinemaAddress').fetch('value')
+  end
+end

data/test/support/fakes.rb

@@ -0,0 +1,31 @@
+require_relative 'fixtures_helper'
+
+class FakeApiResponse
+  include FixturesHelper
+
+  attr_reader :requests
+
+  def initialize
+    @requests = 0
+  end
+
+  def cinemas
+    JSON.parse(cinemas_json).fetch('result').flat_map { |group| group.fetch('cinemas') }
+  end
+
+  def films(cinema_id)
+    @requests += 1
+    JSON.parse(films_json(cinema_id)).fetch('result')
+  end
+end
+
+class FakeWebsite
+  include FixturesHelper
+
+  def cinema(url)
+    id = url[%r{/cinema/accrington/}] ? '10051' : (raise "No fixture for #{url}")
+    html = cinema_page_html(id)
+    JSON.parse(html[%r{<script id="__NEXT_DATA__"[^>]*>(.*?)</script>}m, 1])
+        .dig('props', 'pageProps', 'layoutData', 'sitecore', 'context', 'cinema')
+  end
+end

data/test/support/fixtures_helper.rb

@@ -0,0 +1,21 @@
+# Read hand-written fixtures from disk. They follow the shape in
+# api_shapes.rb; they are never recorded output from myvue.com.
+module FixturesHelper
+  private
+
+  def cinemas_json
+    read_fixture('api/cinemas.json')
+  end
+
+  def films_json(cinema_id)
+    read_fixture("api/films-#{cinema_id}.json")
+  end
+
+  def cinema_page_html(cinema_id)
+    read_fixture("website/cinema-#{cinema_id}.html")
+  end
+
+  def read_fixture(filepath)
+    File.read(File.expand_path("../../fixtures/#{filepath}", __FILE__))
+  end
+end