Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

20.7 KB
Raw Blame
defmodule PlausibleWeb.Live.FunnelSettingsTest do
  use PlausibleWeb.ConnCase, async: false
  @moduletag :ee_only

  on_ee do
    import Phoenix.LiveViewTest

    describe "GET /:domain/settings/funnels" do
      setup [:create_user, :log_in, :create_site]

      test "premium feature notice renders", %{conn: conn, site: site, user: user} do
        user
        |> team_of()
        |> Plausible.Teams.Team.end_trial()
        |> Plausible.Repo.update!()

        conn = get(conn, "/#{site.domain}/settings/funnels")
        resp = conn |> html_response(200)

        assert text(resp) =~ "upgrade your subscription"
      end

      test "guest editors should be able to access funnel settings", %{site: site, conn: conn} do
        guest_user = new_user()
        add_guest(site, user: guest_user, role: :editor)

        {:ok, conn: conn} = log_in(%{user: guest_user, conn: conn})

        lock_notice =
          conn
          |> get("/#{site.domain}/settings/funnels")
          |> html_response(200)
          |> text_of_element("#lock-notice")

        refute lock_notice =~ "upgrade your subscription"
      end

      test "lists funnels for the site and renders help link", %{conn: conn, site: site} do
        {:ok, _} = setup_funnels(site)
        conn = get(conn, "/#{site.domain}/settings/funnels")

        resp = html_response(conn, 200)
        assert resp =~ "Compose goals into funnels"
        assert resp =~ "From blog to signup"
        assert resp =~ "From signup to blog"
        refute resp =~ "Your account does not have access"
        refute resp =~ "upgrade your subscription"
        assert element_exists?(resp, "a[href=\"https://plausible.io/docs/funnel-analysis\"]")
      end

      test "search funnels input is rendered", %{conn: conn, site: site} do
        {:ok, _} = setup_funnels(site)
        conn = get(conn, "/#{site.domain}/settings/funnels")
        resp = html_response(conn, 200)
        assert element_exists?(resp, ~s/input[type="text"]#filter-text/)
        assert element_exists?(resp, ~s/form[phx-change="filter"]#filter-form/)
      end

      test "lists funnels with delete actions", %{conn: conn, site: site} do
        {:ok, [f1_id, f2_id]} = setup_funnels(site)
        conn = get(conn, "/#{site.domain}/settings/funnels")

        resp = html_response(conn, 200)

        assert element_exists?(
                 resp,
                 ~s/button[phx-click="delete-funnel"][phx-value-funnel-id="#{f1_id}"]#delete-funnel-#{f1_id}/
               )

        assert element_exists?(
                 resp,
                 ~s/button[phx-click="delete-funnel"][phx-value-funnel-id="#{f2_id}"]#delete-funnel-#{f2_id}/
               )
      end

      test "if goals are present, Add Funnel button is rendered", %{conn: conn, site: site} do
        {:ok, _} = setup_funnels(site)
        conn = get(conn, "/#{site.domain}/settings/funnels")
        resp = conn |> html_response(200)
        assert element_exists?(resp, ~S/button[phx-click="add-funnel"]/)
      end
    end

    describe "FunnelSettings live view" do
      setup [:create_user, :log_in, :create_site]

      test "allows dashboard toggle", %{conn: conn, site: site} do
        lv = get_liveview(conn, site)
        lv |> element("#feature-funnels-toggle button") |> render_click()
        assert render(lv) =~ "Funnels are now hidden from your dashboard"
        assert Plausible.Billing.Feature.Funnels.opted_out?(Plausible.Repo.reload!(site))
        lv |> element("#feature-funnels-toggle button") |> render_click()
        assert render(lv) =~ "Funnels are now visible again on your dashboard"
        refute Plausible.Billing.Feature.Funnels.opted_out?(Plausible.Repo.reload!(site))
      end

      test "allows list filtering / search", %{conn: conn, site: site} do
        {:ok, _} = setup_funnels(site, ["Funnel One", "Search Me"])
        {lv, html} = get_liveview(conn, site, with_html?: true)

        assert html =~ "Funnel One"
        assert html =~ "Search Me"

        html = type_into_search(lv, "search")

        refute html =~ "Funnel One"
        assert html =~ "Search Me"
      end

      test "allows resetting filter text via backspace icon", %{conn: conn, site: site} do
        {:ok, _} = setup_funnels(site, ["Funnel One", "Another"])
        {lv, html} = get_liveview(conn, site, with_html?: true)

        refute element_exists?(html, ~s/svg[phx-click="reset-filter-text"]#reset-filter/)

        html = type_into_search(lv, "one")
        refute html =~ "Another"

        assert element_exists?(html, ~s/svg[phx-click="reset-filter-text"]#reset-filter/)

        html = lv |> element(~s/svg#reset-filter/) |> render_click()

        assert html =~ "Funnel One"
        assert html =~ "Another"
      end

      test "allows resetting filter text via no match link", %{conn: conn, site: site} do
        {:ok, _} = setup_funnels(site)
        lv = get_liveview(conn, site)
        html = type_into_search(lv, "Definitely this is not going to render any matches")

        assert html =~ "No funnels found for this site. Please refine or"
        assert html =~ "reset your search"

        assert element_exists?(html, ~s/a[phx-click="reset-filter-text"]#reset-filter-hint/)
        html = lv |> element(~s/a#reset-filter-hint/) |> render_click()

        refute html =~ "No funnels found for this site. Please refine or"
      end

      test "allows to delete funnels", %{conn: conn, site: site} do
        {:ok, [f1_id, _f2_id]} = setup_funnels(site)

        {lv, html} = get_liveview(conn, site, with_html?: true)

        assert html =~ "From blog to signup"
        assert html =~ "From signup to blog"

        html = lv |> element(~s/button#delete-funnel-#{f1_id}/) |> render_click()

        refute html =~ "From blog to signup"
        assert html =~ "From signup to blog"

        html = get(conn, "/#{site.domain}/settings/funnels") |> html_response(200)

        refute html =~ "From blog to signup"
        assert html =~ "From signup to blog"
      end

      test "renders the funnel form on clicking 'Add Funnel' button", %{conn: conn, site: site} do
        setup_goals(site)
        lv = get_liveview(conn, site)
        doc = render_click(lv, "add-funnel")

        assert element_exists?(
                 doc,
                 ~s/form[phx-change="validate"][phx-submit="save"]/
               )

        assert element_exists?(doc, ~s/form input[type="text"][name="funnel[name]"]/)

        step_setup_controls = [
          ~s/#step-1 select[hidden][name="funnel[steps][1][step_data]"]/,
          ~s/#step-2 select[hidden][name="funnel[steps][2][step_data]"]/,
          ~s/#step-1 input[type="text"]/,
          ~s/#step-2 input[type="text"]/,
          ~s/a[phx-click="add-step"]/
        ]

        Enum.each(step_setup_controls, &assert(element_exists?(doc, &1)))
      end

      test "clicking 'Add another step' adds a pair of inputs and renders remove step buttons", %{
        conn: conn,
        site: site
      } do
        setup_goals(site)
        lv = get_liveview(conn, site)

        lv |> element(~s/button[phx-click="add-funnel"]/) |> render_click()

        assert lv = find_live_child(lv, "funnels-form")
        lv |> element("form") |> render_change(%{funnel: %{name: "My test funnel"}})
        doc = lv |> element(~s/a[phx-click="add-step"]/) |> render_click()

        assert element_exists?(
                 doc,
                 ~s/#step-3 select[hidden][name="funnel[steps][3][step_data]"]/
               )

        assert element_exists?(doc, ~s/#step-3 input[type="text"]/)

        assert element_exists?(
                 doc,
                 ~s/svg#remove-step-1[phx-click="remove-step"][phx-value-step-idx="1"]/
               )

        assert element_exists?(
                 doc,
                 ~s/svg#remove-step-2[phx-click="remove-step"][phx-value-step-idx="2"]/
               )

        assert element_exists?(
                 doc,
                 ~s/svg#remove-step-3[phx-click="remove-step"][phx-value-step-idx="3"]/
               )
      end

      test "clicking the 'remove step' button removes a step", %{site: site, conn: conn} do
        setup_goals(site)
        lv = get_liveview(conn, site)

        lv |> element(~s/button[phx-click="add-funnel"]/) |> render_click()
        assert lv = find_live_child(lv, "funnels-form")
        lv |> element("form") |> render_change(%{funnel: %{name: "My test funnel"}})
        lv |> element(~s/a[phx-click="add-step"]/) |> render_click()

        doc = lv |> element(~s/#remove-step-2/) |> render_click()

        assert element_exists?(doc, ~s/#step-1 input/)
        assert element_exists?(doc, ~s/#step-3 input/)
        refute element_exists?(doc, ~s/#step-2 input/)
      end

      test "save button saves strict-order setting", %{
        conn: conn,
        site: site
      } do
        {:ok, [g1, g2]} = setup_goals(site)

        {:ok, %Plausible.Funnel{funnel_type: :sequential} = funnel} =
          Plausible.Funnels.create(
            site,
            "Strict funnel",
            [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}],
            funnel_type: :sequential
          )

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        assert element_exists?(
                 render(lv),
                 ~s/input#funnel_funnel_type_sequential[checked]/
               )

        lv
        |> element(~s/input#funnel_funnel_type_strict[phx-click="switch-type"]/)
        |> render_click()

        refute element_exists?(
                 render(lv),
                 ~s/input#funnel_funnel_type_sequential[checked]/
               )

        assert element_exists?(
                 render(lv),
                 ~s/input#funnel_funnel_type_strict[checked]/
               )

        lv
        |> element(~s/form/)
        |> render_submit()

        assert %Plausible.Funnel{funnel_type: :strict} =
                 Plausible.Funnels.get(site, "Strict funnel")
      end

      test "save button saves flexible setting", %{
        conn: conn,
        site: site
      } do
        {:ok, [g1, g2]} = setup_goals(site)

        {:ok, %Plausible.Funnel{funnel_type: :sequential} = funnel} =
          Plausible.Funnels.create(
            site,
            "Flexible funnel",
            [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}],
            funnel_type: :sequential
          )

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        assert element_exists?(
                 render(lv),
                 ~s/input#funnel_funnel_type_sequential[checked]/
               )

        lv
        |> element(~s/input#funnel_funnel_type_flexible[phx-click="switch-type"]/)
        |> render_click()

        refute element_exists?(
                 render(lv),
                 ~s/input#funnel_funnel_type_sequential[checked]/
               )

        assert element_exists?(
                 render(lv),
                 ~s/input#funnel_funnel_type_flexible[checked]/
               )

        lv
        |> element(~s/form/)
        |> render_submit()

        assert %Plausible.Funnel{funnel_type: :flexible} =
                 Plausible.Funnels.get(site, "Flexible funnel")
      end

      test "editing a funnel pre-renders it", %{
        conn: conn,
        site: site
      } do
        {:ok, [f1_id, _]} = setup_funnels(site)
        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{f1_id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        %{"display_name" => "Visit /go/to/blog/**"} =
          lv
          |> element("#step-1_submit option[selected]")
          |> render()
          |> text_of_attr("value")
          |> JSON.decode!()

        %{"display_name" => "Signup"} =
          lv
          |> element("#step-2_submit option[selected]")
          |> render()
          |> text_of_attr("value")
          |> JSON.decode!()
      end

      test "funnel is re-evaluated when strict-order is changed", %{
        conn: conn,
        site: site
      } do
        {:ok, [g1, g2]} = setup_goals(site)

        {:ok, funnel} =
          Plausible.Funnels.create(
            site,
            "Strict-order switch",
            [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}]
          )

        ts = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)

        populate_stats(site, [
          build(:pageview,
            pathname: "/go/to/blog/foo",
            user_id: 123,
            timestamp: NaiveDateTime.add(ts, -2, :second)
          ),
          build(:pageview,
            pathname: "/intervention",
            user_id: 123,
            timestamp: NaiveDateTime.add(ts, -1, :second)
          ),
          build(:event,
            name: "Signup",
            user_id: 123,
            timestamp: ts
          )
        ])

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        assert text_of_element(render(lv), ~s/#step-eval-1/) =~ "Dropoff: 0%"
        assert text_of_element(render(lv), ~s/#funnel-eval/) =~ "Last month conversion rate: 100%"

        lv
        |> element(~s/input#funnel_funnel_type_strict[phx-click="switch-type"]/)
        |> render_click()

        assert text_of_element(render(lv), ~s/#step-eval-1/) =~ "Dropoff: 100%"
        assert text_of_element(render(lv), ~s/#funnel-eval/) =~ "Last month conversion rate: 0%"
      end

      test "funnel is re-evaluated when flexible is set", %{
        conn: conn,
        site: site
      } do
        {:ok, g1} = Plausible.Goals.create(site, %{"page_path" => "/go/to/blog/**"})
        {:ok, g2} = Plausible.Goals.create(site, %{"event_name" => "Signup"})
        {:ok, g3} = Plausible.Goals.create(site, %{"event_name" => "Purchase"})

        {:ok, funnel} =
          Plausible.Funnels.create(
            site,
            "Flexible switch",
            [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}, %{"goal_id" => g3.id}]
          )

        ts = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)

        populate_stats(site, [
          build(:pageview,
            pathname: "/go/to/blog/foo",
            user_id: 123,
            timestamp: NaiveDateTime.add(ts, -2, :second)
          ),
          build(:event,
            name: "Purchase",
            user_id: 123,
            timestamp: ts
          )
        ])

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        assert text_of_element(render(lv), ~s/#funnel-eval/) =~ "Last month conversion rate: 0%"

        lv
        |> element(~s/input#funnel_funnel_type_flexible[phx-click="switch-type"]/)
        |> render_click()

        assert text_of_element(render(lv), ~s/#funnel-eval/) =~ "Last month conversion rate: 100%"
      end

      test "funnel evaluation respects additional properties like scroll threshold and custom props",
           %{
             conn: conn,
             site: site
           } do
        {:ok, g1} =
          Plausible.Goals.create(site, %{
            "page_path" => "/go/to/blog/**",
            "scroll_threshold" => 90
          })

        {:ok, g3} = Plausible.Goals.create(site, %{"event_name" => "Purchase"})

        {:ok, funnel} =
          Plausible.Funnels.create(
            site,
            "Mixed funnel",
            [
              %{"goal_id" => g1.id},
              %{"event_name" => "Signup", "custom_props" => %{"method" => "oauth"}},
              %{"goal_id" => g3.id}
            ]
          )

        ts =
          NaiveDateTime.utc_now()
          |> NaiveDateTime.truncate(:second)
          |> NaiveDateTime.add(-600, :second)

        populate_stats(site, [
          build(:pageview, pathname: "/go/to/blog/foo", user_id: 122, timestamp: ts),
          build(:engagement,
            pathname: "/go/to/blog/foo",
            scroll_depth: 92,
            user_id: 122,
            timestamp: NaiveDateTime.add(ts, 1, :second)
          ),
          build(:event,
            name: "Signup",
            "meta.key": ["method"],
            "meta.value": ["oauth"],
            user_id: 122,
            timestamp: NaiveDateTime.add(ts, 2, :second)
          ),
          build(:event,
            name: "Purchase",
            user_id: 122,
            timestamp: NaiveDateTime.add(ts, 3, :second)
          ),
          build(:pageview, pathname: "/go/to/blog/foo", user_id: 123, timestamp: ts),
          build(:engagement,
            pathname: "/go/to/blog/foo",
            scroll_depth: 98,
            user_id: 123,
            timestamp: NaiveDateTime.add(ts, 1, :second)
          ),
          build(:event,
            name: "Signup",
            "meta.key": ["method"],
            "meta.value": ["email"],
            user_id: 123,
            timestamp: NaiveDateTime.add(ts, 2, :second)
          ),
          build(:event,
            name: "Purchase",
            user_id: 123,
            timestamp: NaiveDateTime.add(ts, 3, :second)
          )
        ])

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        assert text_of_element(render(lv), ~s/#funnel-eval/) =~ "Last month conversion rate: 50%"
      end

      test "clicking save after editing the funnel, updates strict-order setting", %{
        conn: conn,
        site: site
      } do
        {:ok, [g1, g2]} = setup_goals(site)

        {:ok, funnel} =
          Plausible.Funnels.create(
            site,
            "Editable strict funnel",
            [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}],
            funnel_type: :sequential
          )

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        lv
        |> element(~s/input#funnel_funnel_type_strict[phx-click="switch-type"]/)
        |> render_click()

        lv
        |> element(~s/form/)
        |> render_submit()

        assert %Plausible.Funnel{funnel_type: :strict} =
                 Plausible.Funnels.get(site, "Editable strict funnel")
      end

      test "clicking save after editing the funnel, updates flexible setting", %{
        conn: conn,
        site: site
      } do
        {:ok, [g1, g2]} = setup_goals(site)

        {:ok, funnel} =
          Plausible.Funnels.create(
            site,
            "Editable flexible funnel",
            [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}],
            funnel_type: :sequential
          )

        lv = get_liveview(conn, site)

        lv
        |> element(~s/button[phx-click="edit-funnel"][phx-value-funnel-id="#{funnel.id}"]/)
        |> render_click()

        assert lv = find_live_child(lv, "funnels-form")

        lv
        |> element(~s/input#funnel_funnel_type_flexible[phx-click="switch-type"]/)
        |> render_click()

        lv
        |> element(~s/form/)
        |> render_submit()

        assert %Plausible.Funnel{funnel_type: :flexible} =
                 Plausible.Funnels.get(site, "Editable flexible funnel")
      end
    end

    defp setup_funnels(site, names \\ []) do
      {:ok, [g1, g2]} = setup_goals(site)

      {:ok, f1} =
        Plausible.Funnels.create(
          site,
          Enum.at(names, 0) || "From blog to signup",
          [%{"goal_id" => g1.id}, %{"goal_id" => g2.id}]
        )

      {:ok, f2} =
        Plausible.Funnels.create(
          site,
          Enum.at(names, 1) || "From signup to blog",
          [%{"goal_id" => g2.id}, %{"goal_id" => g1.id}]
        )

      {:ok, [f1.id, f2.id]}
    end

    defp setup_goals(site) do
      {:ok, g1} = Plausible.Goals.create(site, %{"page_path" => "/go/to/blog/**"})
      {:ok, g2} = Plausible.Goals.create(site, %{"event_name" => "Signup"})
      {:ok, [g1, g2]}
    end

    defp get_liveview(conn, site, opts \\ []) do
      conn = assign(conn, :live_module, PlausibleWeb.Live.FunnelSettings)
      {:ok, lv, html} = live(conn, "/#{site.domain}/settings/funnels")

      if Keyword.get(opts, :with_html?) do
        {lv, html}
      else
        lv
      end
    end

    defp type_into_search(lv, text) do
      lv
      |> element("form#filter-form")
      |> render_change(%{
        "_target" => ["filter-text"],
        "filter-text" => "#{text}"
      })
    end
  end
end