Sin[x]==0 is an expression. It's not a string. It's not wrapped in Hold. So, each time Mathematica sees encounters test it will "evaluate" it (i.e. apply its rewrite ruies, in this case using OwnValues). And once that replacement is made, it will try to evaluate again. If x has a value (i.e. it has OwnValues) then that replacement will be done. And so on.

Maybe it will help if you use Trace.

Clear[x, test]

test = Sin[x] == 0
(*evaluates immediately and outputs Sin[x] == 0*)

Trace[test]
(*{test,Sin[x]==0}*)

x = Pi

Trace[test]
(*{test,Sin[x]==0,{{x,\[Pi]},Sin[\[Pi]],0},0==0,True}*)

Furthermore, note that OwnValues[test] has not changed

OwnValues[test]
(*{HoldPattern[test]:>Sin[x]==0}*)

That's just because RuleDelayed has the attribute HoldRest. Of course, you can explicitly change it:

test = Sin[x] == 0
(*True*)

OwnValues[test]
(*{HoldPattern[test]:>True}*)

If x is unassigned, then the expression Sin[x]==0 cannot be evaluated further. That's just a consequence of the rules for Sin and Equal. So, it turns out that the immediate evaluation of Sin[x]==0 effects no change to that expression. SetDelayed holds the right hand side unevaluated, but in this case, you get the same result whether you evaluate it or not. What Gianluca showed you illustrates the difference between Set and SetDelayed by making it possible to further evaluate Sin[x]==0 (by assigning a value to x). In otherwords, the fact that OwnValues[test] is the same in both cases is a coincidence due to the particular expression you chose to assign to test.

Try this to feel the difference:

x = Pi/2;
testImmediate = Sin[x] == 0;
testDelayed := Sin[x] == 0;
OwnValues[testImmediate]
OwnValues[testDelayed]