You are breaking a few rules in your code.

1. _ matches anything on the left side of a assignment, not on the right side, where you are defining your values.
2. _ works with the = (match) operator not with the `==’ (comparison) operator.
3. you cannot use the = operator in guards

Anyway, There are at least two ways of doing it, one with match? as @al2o3cr mentioned, another one with guards.

foo = {:ok, :bosh}

cond do
  match?({:pass, _}, foo) ->
    1

  match?({:ok, _, _}, foo) or match?({:ok, :bosh}, foo) ->
    2
end

case foo do
  {:pass, _} ->
    1

  foo
  when is_tuple(foo) and tuple_size(foo) == 2 and elem(foo, 0) == :ok
  when is_tuple(foo) and tuple_size(foo) == 3 and elem(foo, 0) == :ok and elem(foo, 1) == :bosh ->
    2

  # previous clause can be optimized like this which can be optimized like this (not so much readable as the previous one though)
  foo
  when is_tuple(foo) and elem(foo, 0) == :ok and
         (tuple_size(foo) == 2 or (tuple_size(foo) == 3 and elem(foo, 1) == :bosh)) ->
    2
end

There is a practical use for the cumbersome second solution, and that is GUARDS! you can define the guard with defguardand use it even in function definitions (since you asked about avoiding repetition)

  defguard is_foo(term)
           when is_tuple(term) and elem(term, 0) == :ok and
                  (tuple_size(term) == 2 or (tuple_size(term) == 3 and elem(term, 1) == :bosh))

case foo do
  {:pass, _} ->
    1

  foo when is_foo(foo)  ->
    2
end