Should this test insert "view" for the validation? I think yes as the schema validates and I think this should also be asserted here then.
And there should be a test that checks that no defaults are entered for a violated schema with defaults in anyOf.

No, I don't think it should be "view", because the validation passed for the second of the anyOf schemas.

The test below this is the second situation you described, I think, and it's actually asserting the opposite: the first of the anyOf values is going to be used as the default, if set. I'm curious what the behavior would be if, say, the second anyOf had the default. Or both. etc.

Ok, lets conclude that the tests are not complete with respect to how insert defaults should behave for anyOf. The same possibly holds for allOf (what if more than one schema has a different default value for the same absent property).
Unfortunately the spec says nothing about defaults in allOf and anyOf (or I overlooked it). So we need to define the behaviour for json-schema and therefore should make it explicit.

In test_default_with_strict_and_anyof, "view" will not be added, because that subschema does not match the data. In test_default_with_anyof, because we pass empty data, the default ("view") gets added, which then means the first subschema validates, and the returned data will contain "view".

The data will only ever contain the defaults for the subschema that first passes validation. The looping search stops at this point and returns early, so it seems like a sane approach to me. But as far as I can tell the spec is silent on all these issues.

If you have specific test cases you think I should cover just let me know.

I can't even think of a sensible approach for allOf. I suspect it hasn't been fully considered. I think I'm personally going to stop using defaults at all in schemas I write.

Ah I see my mistake. I overlooked strict, which makes the first schema in the first test to not validate. In this respect I agree that this is fine.
My hypothetical question is, whether the following test should hold:

def test_default_with_anyof_no_strict
  schema = {
    "anyOf" => [
      {
        "type" => "object",
        "properties" => {
          "foo" => {
            "enum" => ["view", "search"],
            "default" => "view"
          }
        }
      },
      {
        "type" => "object",
        "properties" => {
          "bar" => {
            "type" => "string",
            "default" => "baz"
          }
        }
      }
    ]
  }
  data = {}
  assert(JSON::Validator.validate(schema, data, :insert_defaults => true))
  assert(data['foo'] == 'view')
  assert(data['bar'] == 'baz')
end

In my view: no. I think assert(data['bar'] == 'baz') should fail. But I agree that it is a judgement call. The spec says nothing either way.

Imagine the complication you would start to get when considering required or additionalProperties. You could build a data structure such that a call to validate would pass, but that would return a modified data structure which would fail if validated again against exact same schema.

But again, I don't think there is a perfect solution.

What I want to say is, that we should sort that stuff out to have a clear line for json-schema where the spec is not explicit. But none of this relates to your PR, so I think we should have an issue that deals with this for the v3 milestone, where we make the behavior explicit, even if it stays the same as it is now.